Java 经典入门(一)

发布时间:2019-03-05  栏目:法律  评论:0 Comments

背景:七月2二十十八日,国家食品药品禁锢总局约谈了国内主要的网络餐饮食服务务平台总管。在那之中囊括饿了么、百度外卖、美团点评公司、到家美食会、金拱门(中夏族民共和国)有限公司、百胜餐饮企业中夏族民共和国事业部、广东海底捞餐饮股份有限公司等。本次主要针对平台对入网公司的审查机制、线上线下的菜品质量、配送环节食物安全防护和买主权益保证等几上边难题展开严厉须求和法规规定。

一 、什么是 Java 技术?为什么需求 Java?

  Java 是由 Sun 七彩虹 在 一九九四年首先揭橥的编程语言和测算平台。有许多应用程序和 Web 站点唯有在安装 Java
后才能健康办事,而且这么的应用程序和 Web 站点稳步增多。Java
急速、安全、可相信。从台式机电脑到数量主导,从娱乐操纵台到正确一流计算机,从手提式有线电话机到互连网,Java
无处不在!

法律 1

  Java是一种总结机编制程序语言,拥有跨平台、面向对象、泛型编制程序的特色,广泛应用于公司级Web应用开发和移动使用开发。

  任职于太阳微系统的James·高斯林等人于1988年份初开发Java语言的雏形,最初被取名为Oak,指标设置在家用电器等小型系统的程序语言,应用在电视、电话、闹钟、烤面包机等家电的支配和通讯。由于那一个智能化家用电器的集镇要求没有预想的高,Sun公司放弃了该项布置。随着一九九〇年份互连网的上进,Sun公司看见Oak在网络上行使的前景,于是改造了Oak,于一九九五年3月以Java的称呼正式发布。Java伴随着互连网的迅猛发展而进步,渐渐变为第1的互连网编制程序语言。

  Java编制程序语言的风格卓殊好像C++语言。继承了C++语言面向对象技术的骨干,Java抛弃了C++语言中易于引起错误的指针,改以引用替换,同时移除原C++与原本运算符重载,也移除多重继承性格,改用接口替换,扩充垃圾回收器作用。在Java
SE
1.5版本中引入了泛型编制程序、类型安全的枚举、不定长参数和自行李装运/拆箱性格。太阳微系统对Java语言的诠释是:“Java编制程序语言是个不难、面向对象、分布式、解释性、健壮、安全与系统非亲非故、可移植、高品质、二十八线程和动态的语言”

  Java不相同于一般的编写翻译语言或直译语言。它首先将源代码编写翻译成字节码,然后倚重各样不一致平台上的虚拟机来分解实施字节码,从而完结了“一次编写,随地运维”的跨平台湾特务性。在最初JVM中,这在一定水平上降落了Java程序的运维功效。但在J2SE1.4.2发布后,Java的运作速度有了大幅度升级。

 

老小叔子食药品监督总局正襟危坐,望着饿了么、美团、金拱门、海底捞等人慢吞吞进场。

贰 、语言特色

Java之所以被开发,是要达到规定的标准以下七个指标:

  • 相应选用面向对象程序设计方艺术学
  • 有道是允许同一程序在分裂的电脑平台实施
  • 应当包含内建的对总计机互连网的支撑
  • 相应被规划成平安地执行远端代码
  • 有道是易于使用,并借鉴在此以前那一个面向对象语言(如C++)的独到之处。

Java技术主要分为多少个部分:Java语言、Java运营条件、类库。一般意况下说Java时并不区分指的是哪位部分。

Java在1.5版本时,做了至关心注重要改变,太阳集团并1.5本子重命名为Java 5.0。

面向对象

  Java的特点之一便是面向对象,是先后设计方式的一种。“面向对象程序设计语言”的宗旨之一正是开发者在筹划软件的时候可以动用自定义的项目和涉嫌操作。代码和多少的莫过于集合体叫做“对象”。三个对象足以设想成绑定了很多“行为(代码)”和“状态(数据)”的实体。对于数据结构的变动须要和代码进行通讯然后操作,反之亦然。面向对象设计让大型软件工程的安插和布署性别变化得更易于管理,能增强工程的平日度,收缩失败工程的数量。

跨平台性

  Java语言的第一性格状就是跨平台性,约等于说使用Java语言编写的先后能够在编写翻译后不用经过任何变更,就能在其他硬件配备条件下运作。那个本性平常被誉为“2次编写翻译,随处运转”。

  执行Java应用程序必须安装Java Runtime
Environment
JRE),JRE内部有三个Java虚拟机(Java Virtual
Machine,JVM)以及一些正式的类库(Class
Library)。通过JVM才能在电脑系统执行Java应用程序(Java
Application),那与.Net
Framework的情事同样,所以电脑上没有安装JVM,那么这几个程序将不可能实施。

  达成跨平台性的方法是绝大部分编写翻译器在开始展览Java语言程序的编码时候会变卦二个用字节码写成的“半成品”,那个“半成品”会在Java虚拟机(解释层)的援救下运作,虚拟机会把它转换到当前所处硬件平台的原始代码。之后,Java虚拟机会打开标准库,进行多少(图片、线程和网络)的访问工作。重要注意的是,尽管已经存在一个开始展览代码翻译的解释层,有个别时候Java的字节码代码依然会被JIT编译器举办贰遍编写翻译。

  有个别编写翻译器,比如GCJ,能够自动生成原始代码而不须求解释层。不过这个编写翻译器所生成的代码只可以采纳于特定平台。并且GCJ近期只补助部分的Java
API。

  草书集团对此Java的许可是“全包容的”,那也促成了微软塌塌升阳关于微软的顺序不帮助TiggoMI和JNI接口、并且扩大特色为己所用的法律纠纷。升阳最终得到了官司,获得了大约两千万法郎的赔偿,法院强制须要微软推行升阳集团有关Java的承认须要。作为回答,微软不再在Windows系统中捆绑Java,最新的Windows版本,Windows
Vista和Internet Explorer
7.0本子也不再提供对于Java应用程序和控件的支撑。不过升阳公司和别的应用Java运营时系统的商店在Windows操作系统下对用户提供职分的第叁方插件和顺序辅助。

  Java语言应用解释层最初是为了轻巧性。所以那个程序的运维功效比C语言和C++要低很多,用户也对此有不少意见。很多近期的查证展现Java的程序运行速度比几年前要高出许多,有个别同样效果的顺序的成效甚至逾越了C++和C语言编写的先后。

  Java语言在最开端应用的时候是尚未表达层的,全部必要编写翻译的代码都直接转换到机器的原始代码。那样做的结果就是赢得了一级的习性,不过程序臃肿非常。从JIT技术开首,Java的主次都因而三次转换之后才改成机器码。很多名牌的第贰方虚拟机都应用一种名叫“动态编写翻译”的技艺,相当于说虚拟机实时监测和分析程序的运营行为,同时选拔性地对先后所需求的一对举办编写翻译和优化。全部那个技巧都一字不苟了代码的周转速度,不过又不会让程序的体量变得有有失水准态。

  程序的轻便性事实上是软件编写制定很难达到规定的标准的二个对象,Java固然成功地贯彻了“1次编写翻译,随处运转”,不过由于平台和平台之间的歧异,所编纂的顺序在更换代码的时候难免会出现细小的、不可察觉的荒唐和奇怪。某个程序员对此尤其脑瓜疼,他们调侃Java的主次不是“二遍编写翻译,随地运维”,而是“2回编写翻译,随地调节和测试”。以Java
AWT为例,早期Java
AWT内提供的按钮、文字区等均是以电脑系统所默许的体裁而显得。那令Java程序在有点没有提供美术的电脑系统产生错误(在Microsoft
Windows设有窗口管理器,在一些Linux
distribution则并未)。后来SUN公司针对Java AWT一些题材而生产Java Swing。

  平台非亲非故性让Java在服务器端软件领域11分成功。很多劳务器端软件都利用Java或有关技能建立。

自动垃圾回收(Garbage Collection)

  C++语言被用户诟病的缘故之一是大多数C++编写翻译器不协理垃圾收集体制。经常接纳C++编制程序的时候,程序员于程序中开头化对象时,会在主机内部存款和储蓄器堆栈上分红一块内部存款和储蓄器与地方,当不须要此目的时,进行析构或许去除的时候再自由分配的内部存款和储蓄器地址。假使目的是在仓库上分红的,而程序员又忘记实行删除,那么就会招致内部存款和储蓄器泄漏(Memory
Leak)。长此未来,程序运转的时候也许会转变很多不拔除的废料,浪费了不要求的内部存储器空间。而且只要一致内部存款和储蓄器地址被剔除五回的话,程序会变得不安宁,甚至倾家荡产。由此有经历的C++程序员都会在剔除之后将指针重置为NULL,然后在剔除以前先判断指针是或不是为NULL。

  C++中也足以利用“智能指针”(SmartPointer)只怕选拔C++托管扩充编写翻译器的方法来落成自动化内部存储器释放,智能指针能够在正式类库中找到,而C++托管扩充被微软的Visual
C++
7.0及以上版本所支撑。智能指针的亮点是不需引入缓慢的垃圾堆收集体制,而且可以不考虑线程安全的题材,不过缺点是一旦不良使用智能指针的话,质量有大概不如垃圾收集体制,而且不断地分配和刑满释放解除劳教内部存款和储蓄器也许引致内部存款和储蓄器碎片,要求手动对堆进行压缩。除此之外,由于智能指针是3个基于模板的功力,所以没有经历的程序员在急需选择多态脾气开始展览活动清理时也大概心中无数。

  Java语言则差异,上述的状态被机关垃圾收集作用自动处理。对象的创办和停放都是在内部存款和储蓄器堆栈上边进行的。当3个对象没有别的引用的时候,Java的机动垃圾收集体制就发挥效率,自动删除那个目的所占用的空间,释放内部存款和储蓄器以制止内部存款和储蓄器泄漏。

  注意程序员不必要修改finalize办法,自动垃圾收集也会产生功用。但是内部存款和储蓄器泄漏并不是就此防止了,当程序员疏忽疏忽地忘记解除二个对象不应有有的引用时,内部存款和储蓄器泄漏照旧不可防止。

  分裂厂商、差别版本的JVM中的内部存储器垃圾回收机制并不完全平等,常常越新本子的内存回收机制越快,IBM、BEA、SUN等等开发JVM的商店都曾扬言过本人制作出了世界上最快的JVM,JVM品质的世界纪录也在频频的被打破并升高。

  IBM有一篇有关Java内部存款和储蓄器回收机制比不激活垃圾收集体制的C++内部存款和储蓄器处理快数倍的技艺小说,而头面包车型客车Java技术书籍《Java编制程序思想》(Thinking
in Java
)也有一段论述Java内部存储器及质量达到甚至超越C++的章节。

 

心灵想着:你们那帮兔崽子,翅膀硬了起来飞扬狂妄了是吧?几天没教育你们,净给自家找事做。

三、环境

Java的三种技术架构:

JAVAEE:Java Platform Enterprise
艾德ition,开发公司条件下的应用程序,主要针对web程序支付;

JAVASE:Java Platform 斯坦dard
艾德ition,完毕桌面应用程序的开支,是别的两者的底蕴;

JAVAME:Java Platform Micro
艾德ition,开发电子消费制品和嵌入式设备,如手提式有线电话机中的程序;

 

JDK下载地址:http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk7-downloads-1880260.html

1,JDK:Java Development
Kit,
java的支出和周转环境,java的开发工具和jre。

2,JRE:Java Runtime
Environment,
java程序的运作条件,java运营的所需的类库+JVM(java虚拟机)。

 

java运维分两步:二个是编写翻译,二个是运维。

    javac:担负的是编译的一对,当执行javac时,会运营java的编写翻译器程序。对点名扩充名的.java文件实行编写翻译。
生成了jvm能够分辨的字节码文件。也便是class文件,相当于java的运作程序。

    java:担当运转的一对.会运维jvm.加载运转时所需的类库,并对class文件进行执行.

    贰个文件要被执行,必供给有2个推行的早先点,这么些初阶点就是main函数.

javac HelloWorld.java
java HelloWorld.class

 

.class文件重庆大学分为两片段:

  • 常量池:    类名,成员变量名和方法引用
  • 主意字节码:  各类艺术的字节码 

运行 java程序的运转进程有多少个阶段:

  • 加载
    即类的.class字节码被加载到内部存款和储蓄器中,一般第1回利用的时候才会加载(惰性加载),那时候会为各类类创建3个Class对象。
  • 开始化
    由可分为静态伊始化和一般开首化,静态初步化在类加载时做到,一般静态发轫化自会在Class对象第三回加载的时候进行二遍,当创立三个目的时,首先会在堆上分配丰盛的蕴藏空间,那时候那块存款和储蓄空间会被清零,
    即对象中的全部骨干数据类型都会被安装成0,然后再实施字段定义处的早先化动作,最终执行构造器。

 

世家一边交头接耳地出口,一边围着圆桌依序坐下。

四、HelloWorld

public class HelloWorld 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello, World!");
    }
}

 

“四哥好!”饿了么、美团等人起立齐声叫道。

5、基本数据类型

4类8种:

1> 逻辑型 — boolean

2> 文本型 — char

3> 整数型 — byte, short, int, long

4> 浮点数型 — float, double

类型 占用存储空间/字节 表数范围
boolean 1/8 true & false
char 2 存储Unicode码,单引号赋值
byte 1 -128 ~ 127
short 2 -2**15 ~ 2**15-1
int 4 -2**31 ~ 2**31-1
long 8 -2**63 ~ 2**63-1
float 4 -3.403E38 ~ 3.403E38
double 8 -1.798E308 ~ 1.798E308

float 与 double 的区别:

  float代表单精度浮点数,叁十二人二进制描述;

  double表示双精度浮点数,63位二进制表示;

  double精度高,有效数字16位,float精度几个人。但double消耗内部存款和储蓄器是float的两倍,double的演算速度比float慢得多。

“好什么好,瞧你们今年都干了些什么事,都坐坐坐!小编轮流来问,三个都不放过。别说话了,都给自家坐好!”

♥常量

实数常量暗许为 double;

平头常量暗中认可为 int。

0x 和 10  内部存款和储蓄器中没差别。

  1>
十六进制整型常量:以十六进制表示时,需以0x或0X早先,如0xff,0X9A。

  2> 八进制整型常量:八进制必须以0初叶,如0123,034。

  3> 长整型:长整型必须以L作最终,如9L,342L。

  4>
浮点数常量:由于小数常量的暗中同意类型是double型,所以float类型的前边必然要加f(F)。同样带小数的变量暗中认可为double类型。如:f=1.3f;

  5>
字符常量:字符型常量需用多少个单引号括起来(注意字符串常量是用八个双引号括起来)。

Java中的字符占七个字节。一些常用的转义字符:

  1> \r表示接受键盘输入,也就是按下了回车键;

  2> \n表示换行;

  3> \t表示制表符,约等于Table键;

  4> \b表示退格键,相当于Back Space键;

  5> \’表示单引号;

  6> \”代表双引号;

  7> \\代表四个斜杠\。

老表哥突然体面起来,大声说道。

 ♥基本数据类型转换

1> boolean 类型不得以转换为其余的数据类型。

2> 体积小的花色自动转换为体量大的数据类型(指代表值得范围大小):

        byte, short, char –> int –> long –> float –> double

    byte, short, char 之间不会互相转换,他们三者在计算时先会转换为 int 类型

3>
体积大的数据类型转换为体量小的数据类型时,要增加强制转换符,也许会招致精度下跌或溢出。

4>
有六连串型的多寡混合运算时,系统第三自动的将有所数据类型转换到体积最大的那一种数据类型,然后再拓展测算。

c 语言之所以无法移植,是因为不相同类别编写翻译后的项目长度不等同

    byte b;
    b = 1;
    int i=b;        // 1
    long l=b;       // 1
    float f=b;      // 1.0
    double d=b;     // 1.0    

// 如果低级类型为char型,向高级类型(整型)转换时,会转换为对应ASCII码值,例:
    char c='c';
    int i=c;        // 99

//对于byte,short,char三种类型而言,他们是平级的,因此不能相互自动转换,可以使用下述的强制类型转换。
    short i=99;
    char c=(char)i;    //c

// float 类型的两种方式
// 在内存中的形式是不一样的
    float f1=0.1f;             // 在内存中是float类型
    float f2=(float)(0.1);     // 在内存中是double类型,强制转换为float类型

// long类型
    long l1=123456;
    long l2=8888888888;        // 错误!!!
    long l3=8888888888L;       // 后面加L

// byte 类型
    byte b1=1;
    byte b2=2; 
    byte b3=129;    // 错误!!!超过最大值

 

饿了么等人意识到空气某个凝重,立马也变得认真起来,连桌上的水都没敢喝。

六、运算符

1> 算数运算符

  +、 -、 *、 /、 %、 ++、 —

2> 赋值运算符

  =、 +=、 -=、 *=、 /=、 %=

3> 关系运算符

  >、 <、 >=、 <=、 ==、 !=

4> 逻辑运算符

  法律,!、 ^、 &、 &&、 |、 ||

    除了 !(逻辑非) 都以用来连接三个 boolean 类型表达式

    &(逻辑与): 唯有两边都为 true 结果是 true, 不然 false;

    &&(短路与): 和 & 一样,但要是左侧为 false,右边就不到场运算;

    |(逻辑或): 唯有两边都为 flase 结果是 false, 不然是 true;

    ||(短路或): 和 | 一样,但假如右侧为 true, 右侧就不出席运算;

    ^(逻辑异): 两边结果同样为 false, 两边结果不相同等为 true;

5> 位运算符

  &、 |、 ^、 ~、 >>、 <<、 >>>

 

法律 2法律 3

// 自加自减练习
// ++、--   在前面是先加减后赋值,在后面是先赋值在加减
        int i1 = 10;
    int i2 = 20;
    int i = i2++;
    System.out.println("i:" + i);    //20,是先赋值在自加!
    System.out.println("i2:" + i2);    //21
    i = ++i2;
    System.out.println("i:" + i);    //22
    System.out.println("i2:" + i2);    //22
    i = --i1;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //9
    i = i1--;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //8

自加自减练习

法律 4法律 5

    // 逻辑运算符练习
    boolean a, b, c;
    a = true; b=false;
    c = !a;        System.out.println(c);    //false
    c = a ^ b;     System.out.println(c);    //true
    c = a & b;     System.out.println(c);    //false
    c = a && b; System.out.println(c);    //false
    c = a | b;     System.out.println(c);    //true
    c = a || b; System.out.println(c);    //true

逻辑运算符演练

 

百胜中中原人民共和国私行对坐在旁边的饿了么说:“四弟好像很恼火,大家明天是否惨了。”

七 、基本语句

1> for 循环

    for(开首化表达式;判断表明式;递增(递减)表明式){
        执行语句;
    }

    •   起头化表明式:开头化表达式的意思,在于定义循环从前变量的值是不怎么。
    •   判断表明式:判断表明式的功能在于规定循环的终端。
    •   递增(递减)表明式:这一项规定每执行一遍程序,变量以多少增量或减量进行变更。

2>  foreach 循环大概、抓牢型循环

            for(类型 变量 : 数组){
        执行语句;
    }

            JDK 1.5 引进了一种新的循环类型,被称呼 foreach
循环或许抓牢型循环,它能在不使用下标的动静下遍历数组。

3> while 循环

    while (条件){
        操作;
    }

4> do while 循环语句

    do/while 语句与 while
语句分化的是,在认清标准以前,先实行大括号内的循环体。

5> switch 语句

    switch (key) {
    case value:

      …
      break;

    default:

      …
      break;
    }

    •   使用 break 语句,避免 case 穿透;
    •   多少个 case key 合并到联合;
    •   default 能够简简单单,
      也以写在肆意地点,假如将default语句放在了第贰行,则无论value是不是匹配,程序会从default初始施行直到第3个break现身;
    •   java 中的 switch 帮忙的花色能够为 byte,char,short,int
      中的一种,JDK版本为1.7及以上帮忙String。

6> break & continue

    跳出整个循环与跳出本次巡回。

7> 长富运算

    布尔表达式?值一:值二

    布尔表明式为true结果为值一,表明式为false结果为值二

    java安慕希表明式有字符强转的效果,会把前边的强转为和近年来的品种一样

  •     要是前方是int型 会把后边字符变成对应的ascii码。
  •     假若前边是char型 会把后边数字转换到对应的字 

 

法律 6法律 7

public class OneHundredAnd{
    public static void main(String[] args){
        int result=0;
        for(int i=1;i<=100;i++){
            result+=i;
        }
        System.out.println(result);
    }
}

for 循环,
计算1+2+3+4……+100的结果

法律 8法律 9

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

foreach 循环

法律 10法律 11

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        while(a<=100){
            result+=a++;
        }
        System.out.println(result);
    }
}

while 循环,
计算1+2+3+4……+100的结果

法律 12法律 13

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        do{
            result+=a++;
        }while(a<=100);
        System.out.println(result);
    }
}

do while 循环,
计算1+2+3+4……+100的结果

法律 14法律 15

public class PrimeNumbers{
    public static void main(String[] args){
        // 输出100~200内的质数
        // 只有1和它本身这两个因数的自然数叫做质数.还可以说成质数只有1和它本身两个约数.
        // 素数是这样的整数,它除了能表示为它自己和1的乘积以外,不能表示为任 何其它两个整数的乘积.
        // 例如: 12 =6×2=4×3,所以12不是素数.

        for (int i=101; i<200; i+=2){
            for (int n=2; n<i; n++){
                if (i % n != 0){
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}

输出100~200内的质数

法律 16法律 17

public class DataConversion {
    public static void main(String[] args){
        switch (18) {
        case 18:
            System.out.print("I'm eighteen years old, fighting.");
            break;
        case 19:
        case 20:
        case 21:
        case 22:
            System.out.print("I'm twenty years old, fighting.");
            break;
        default:
            System.out.print("Grow up to go away ^.^.");
            break;
        }
    }
}

case 语句 practice

法律 18法律 19

public class SimpleUnary{
 public static void main(String[] args) {
   char a = 'a';
   int b = 8;

   System.out.println(false?a:b); //打印b,b是8,所以打印出8
   System.out.println(false?a:8); //打印8,但a是char型的,所以打印8的char字 //符,也就是backspace
   System.out.println(false?8:a); //打印int型,也就是a
   System.out.println(false?b:'a'); //打印a的ASCII码

 }
}

大年终一运算 practice

 

饿了么回:“别怕兄弟,大家都以马阿爹的子女,作者会照顾好你的。你别忘了美团和海底捞也在吗,二零一九年她们的题目才又多又严重。”

八、Number 类

具备的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类
Number 的子类。

 

序号 方法与描述
1 xxxValue()     将number对象转换为xxx数据类型的值并返回。
2 compareTo()  将number对象与参数比较。
3 equals()     判断number对象是否与参数相等。
4 valueOf()   返回一个 Number 对象指定的内置数据类型
5 toString()   以字符串形式返回值。
6 parseInt()  将字符串解析为int类型。
7 abs()    返回参数的绝对值。
8 ceil()    对整形变量向左取整,返回类型为double型。
9 floor()   对整型变量向右取整。返回类型为double类型。
10 rint()    返回与参数最接近的整数。返回类型为double。
11 round()  返回一个最接近的int、long型值。
12 min()   返回两个参数中的最小值。
13 max()   返回两个参数中的最大值。
14 exp()    返回自然数底数e的参数次方。
15 log()     返回参数的自然数底数的对数值。
16 pow()   返回第一个参数的第二个参数次方。
17 sqrt()   求参数的算术平方根。
18 sin()     求指定double类型参数的正弦值。
19 cos()    求指定double类型参数的余弦值。
20 tan()    求指定double类型参数的正切值。
21 asin()   求指定double类型参数的反正弦值。
22 acos()   求指定double类型参数的反余弦值。
23 atan()  求指定double类型参数的反正切值。
24 atan2()  将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25 toDegrees()  将参数转化为角度。
26 toRadians()  将角度转换为弧度。
27 random()     返回一个随机数。

 

法律 20法律 21

public class Numbers {
    public static String getType(Object o){
        return o.getClass().toString();
    }
    public static void main(String[] args){
//        // xxxValue() 将number对象转换为xxx数据类型的值并返回。
//        Integer i1=1;
//        float f1 = i1.floatValue();
//        System.out.println(f1 + " " + getType(f1));    //1.0 class java.lang.Float
//        int f2 = i1.intValue();
//        System.out.println(f2 + " " + getType(f2));    //1 class java.lang.Integer
//        byte f3 = i1.byteValue();
//        System.out.println(f3 + " " + getType(f3));    //1 class java.lang.Byte
////        i1.compareTo(1);

//        // 比较这个Number对象的参数. 一样返回0,否则-1.
//        Integer i1=1;
//        int i2 = i1.compareTo(1);
//        System.out.println(i2);

//        // 确定这个数字对象是否等于参数.一样返回true,否则false.
//        Integer i1=1;
//        byte i2=1;
//        boolean i3 = i1.equals(i2);
//        System.out.println(i3);    //false

//        //返回一个 Number 对象指定的内置数据类型
//        //nteger.valueOf()方法基于减少对象创建次数和节省内存的考虑,
//        //缓存了[-128,127]之间的数字。此数字范围内传参则直接返回缓存中的对象。
//        Integer i1=1;
//        Integer i2 = Integer.valueOf(i1);
//        System.out.println(i2);    //1

//        //以字符串形式返回值。
//        Integer i1=1;
//        String i2 = i1.toString();
//        System.out.println(i2);    //1

//        //将字符串解析为int类型。
//        String i1="9";
//        Integer i2 = Integer.parseInt(i1);
//        System.out.println(i2);    //9

//        //返回参数的绝对值。
//        Integer i1=-1;
//        Integer i2 = Math.abs(i1);
//        System.out.println(i2);    //1

//        //对整形变量向左取整,返回类型为double型。
//        int i1=1;
//        double i2 = Math.ceil(i1);
//        System.out.println(i2);    //1.0

//        //对整型变量向右取整。返回类型为double类型。
//        int i1=1;
//        double i2 = Math.floor(i1);
//        System.out.println(i2);    //1.0

//        //返回与参数最接近的整数。返回类型为double。
//        double i1=1.623;
//        double i2 = Math.rint(i1);
//        System.out.println(i2);    //2.0

//        //返回一个最接近的int、long型值。
//        double i1=1.623;
//        long i2 = Math.round(i1);
//        System.out.println(i2);    //2

//        //返回两个参数中的最小值。
//        double i1=1.6;
//        double i2=1.8;
//        double i3 = Math.min(i1, i2);
//        System.out.println(i3);    //1.6

//        //返回两个参数中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9

//        //返回两个参数中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9

//        //返回自然数底数e的参数次方。
//        double i1=9;
//        double i2 = Math.exp(i1);
//        System.out.println(i2);    //8103.083927575384

//        //返回参数的自然数底数的对数值。
//        double i1=9;
//        double i2 = Math.log(i1);
//        System.out.println(i2); //2.1972245773362196

//        //返回第一个参数的第二个参数次方。2的3次方.
//        double i1=2;
//        double i2=3;
//        double i3 = Math.pow(i1, i2);
//        System.out.println(i3);    //8.0

//        //求参数的算术平方根。
//        double i1=9;
//        double i2 = Math.sqrt(i1);
//        System.out.println(i2);    //3.0

//        //求指定double类型参数的正弦值。
//        double i1=3;
//        double i2 = Math.sin(i1);
//        System.out.println(i2);    //3.0

//        //求指定double类型参数的余弦值。
//        double i1=3;
//        double i2 = Math.cos(i1);
//        System.out.println(i2);    //-0.9899924966004454

//        //求指定double类型参数的正切值。
//        double i1=3;
//        double i2 = Math.tan(i1);
//        System.out.println(i2);    //-0.1425465430742778

//        //求指定double类型参数的反正弦值。NaN
//        double i1=1;
//        double i2 = Math.asin(i1);
//        System.out.println(i2);    //1.5707963267948966

//        //求指定double类型参数的反余弦值。NaN
//        double i1=2;
//        double i2 = Math.acos(i1);
//        System.out.println(i2);    //0.0

//        //求指定double类型参数的反正切值。
//        double i1=3;
//        double i2 = Math.atan(i1);
//        System.out.println(i2);    //1.2490457723982544

//        //将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
//        double i1=3;
//        double i2=3;
//        double i3 = Math.atan2(i1, i2);
//        System.out.println(i3); //0.7853981633974483

//        //将参数转化为角度。
//        double i1=3;
//        double i2 = Math.toDegrees(i1);
//        System.out.println(i2);    //171.88733853924697

//        //将角度转换为弧度。
//        double i1=3;
//        double i2 = Math.toRadians(i1);
//        System.out.println(i2);    //0.05235987755982988

//        //返回一个随机数。
//        double i1 = Math.random();
//        System.out.println(i1);    //0.9591935059236623

    }
}

Number practice

 

百胜欣慰地方了点头,并偷偷望了坐在对面的美团一眼。坐在饿了么另一旁的百度外卖兄弟也点了点头。

九、Character 类

Character 类用于对单个字符实行操作。

Character 类在目的中封装2当中央类型 char 的值

 

序号 方法与描述
1 isLetter() 是否是一个字母
2 isDigit()   是否是一个数字字符
3 isWhitespace() 是否是一个空格
4 isUpperCase()  是否是大写字母
5 isLowerCase()  是否是小写字母
6 toUpperCase()  指定字母的大写形式
7 toLowerCase()  指定字母的小写形式
8 toString()  返回字符的字符串形式,字符串的长度仅为1

 

法律 22法律 23

public class Characters {
    public static void main(String[] args){
        char c1 = 'm';

//        //是否是一个字母
//        boolean b1 = Character.isLetter(c1);
//        System.out.println(b1);    //true

//        //是否是一个数字字符
//        boolean b1 = Character.isDigit(c1);
//        System.out.println(b1);    //false

//        //是否是一个空格
//        boolean b1 = Character.isWhitespace(c1);
//        System.out.println(b1);    //false

//        //是否是大写字母
//        boolean b1 = Character.isUpperCase(c1);
//        System.out.println(b1);    //false

//        //是否是小写字母
//        boolean b1 = Character.isLowerCase(c1);
//        System.out.println(b1);    //true

//        //指定字母的大写形式,变大写
//        char b1 = Character.toUpperCase(c1);
//        System.out.println(b1);    //M

//        //指定字母的小写形式,变小写
//        char b1 = Character.toLowerCase(c1);
//        System.out.println(b1);    //m

//        //返回字符的字符串形式,字符串的长度仅为1
//        String b1 = Character.toString(c1);
//        System.out.println(b1);    //m
    }    
}

Character practice

 

语音刚落,老四哥就好像听到了饿了么和百胜两人的对话,默契地对着他左边边的美团吼了一声:“美团,就你先起来了!”

十、String 类

应用首要字和构造方法来创制 String 对象。

String 类是不行变更的,所以你一旦成立了 String
对象,那它的值就无法更改了(若是急需对字符串做过多修改,那么应该选用选取 StringBuffer
& StringBuilder 类)

String 类有 11
种构造方法,那一个格局提供差别的参数来起初化字符串,比如提供三个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] hello = { 's', 'u', 'o', 'n', 'i', 'n', 'g'};
      String hellos = new String(hello);  
      System.out.println( hellos );
   }
}

法律 24法律 25

String() 
          初始化一个新创建的 String 对象,它表示一个空字符序列。 
String(byte[] bytes) 
          构造一个新的 String,方法是使用平台的默认字符集解码字节的指定数组。 
String(byte[] ascii, int hibyte) 
          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 起,完成该转换的首选方法是通过 String 构造方法,该方法接受一个字符集名称或使用平台的默认字符集。 
String(byte[] bytes, int offset, int length) 
          构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] ascii, int hibyte, int offset, int count) 
          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始,完成该转换的首选方法是通过 String 构造方法,它接受一个字符集名称,或者使用平台默认的字符集。 
String(byte[] bytes, int offset, int length, String charsetName) 
          构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] bytes, String charsetName) 
          构造一个新的 String,方法是使用指定的字符集解码指定的字节数组。 
String(char[] value) 
          分配一个新的 String,它表示当前字符数组参数中包含的字符序列。 
String(char[] value, int offset, int count) 
          分配一个新的 String,它包含来自该字符数组参数的一个子数组的字符。 
String(int[] codePoints, int offset, int count) 
          分配一个新的 String,它包含该 Unicode 代码点数组参数的一个子数组的字符。 
String(String original) 
          初始化一个新创建的 String 对象,表示一个与该参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的一个副本。 
String(StringBuffer buffer) 
          分配一个新的字符串,它包含当前包含在字符串缓冲区参数中的字符序列。

String 类 11 种构造方法

 

序号 方法描述
1 char charAt(int index)
返回指定索引处的 char 值。
2 int compareTo(Object o)
把这个字符串和另一个对象比较。
3 int compareTo(String anotherString)
按字典顺序比较两个字符串。
4 int compareToIgnoreCase(String str)
按字典顺序比较两个字符串,不考虑大小写。
5 String concat(String str)
将指定字符串连接到此字符串的结尾。
6 boolean contentEquals(StringBuffer sb)
当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
7 static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。
9 boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
10 boolean equals(Object anObject)
将此字符串与指定的对象比较。
11 boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较,不考虑大小写。
12 byte[] getBytes()
 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
13 byte[] getBytes(String charsetName)
使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。
15 int hashCode()
返回此字符串的哈希码。
16 int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。
17 int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。
18 int indexOf(String str)
 返回指定子字符串在此字符串中第一次出现处的索引。
19 int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。
20 String intern()
 返回字符串对象的规范化表示形式。
21 int lastIndexOf(int ch)
 返回指定字符在此字符串中最后一次出现处的索引。
22 int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
23 int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
24 int lastIndexOf(String str, int fromIndex)
 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
25 int length()
返回此字符串的长度。
26 boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
29 String replace(char oldChar, char newChar)
返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31 String replaceFirst(String regex, String replacement)
 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32 String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
33 String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。
34 boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始。
35 boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36 CharSequence subSequence(int beginIndex, int endIndex)
 返回一个新的字符序列,它是此序列的一个子序列。
37 String substring(int beginIndex)
返回一个新的字符串,它是此字符串的一个子字符串。
38 String substring(int beginIndex, int endIndex)
返回一个新字符串,它是此字符串的一个子字符串。
39 char[] toCharArray()
将此字符串转换为一个新的字符数组。
40 String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41 String toLowerCase(Locale locale)
 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42 String toString()
 返回此对象本身(它已经是一个字符串!)。
43 String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44 String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45 String trim()
返回字符串的副本,忽略前导空白和尾部空白。
46 static String valueOf(primitive data type x)
返回给定data type类型x参数的字符串表示形式。

 

法律 26法律 27

import java.nio.charset.Charset;

import javax.print.DocFlavor.BYTE_ARRAY;


public class Strings {
    public static void main(String[] args){
        String s1 = "suoning";
        String s2 = "nick";

//        //返回指定索引处的 char 值。
//        char c1 = s1.charAt(3);
//        System.out.println(c1);    //n

//        //把这个字符串和另一个对象比较.等于返回0,此字符串小于字符串参数返回小于0,大于返回大于0.
//        int c1 = s1.compareTo(s2);
//        System.out.println(c1);    //5

//        //将指定字符串连接到此字符串的结尾。
//        String c1 = s1.concat(s2);
//        System.out.println(c1);    //suoningnick

//        //当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
//        StringBuffer s3 = new StringBuffer("suoning");
//        boolean c1 = s1.contentEquals(s3);
//        System.out.println(c1);    //true

//        //返回指定数组中表示该字符序列的 String。
//        char[] s3 = {'s', 'u', 'o', ' ', 'n', 'i', 'n', 'g'};
//        String c1 = s1.copyValueOf(s3);
//        System.out.println(c1);    //suo ning
//        String c2 = s1.copyValueOf(s3, 1, 6);
//        System.out.println(c2);    //uo nin

//        //测试此字符串是否以指定的后缀结束。
//        boolean c1 = s1.endsWith(s2);
//        System.out.println(c1);    //false

//        //将此字符串与指定的对象比较。
//        boolean c1 = s1.equals(s2);
//        System.out.println(c1);    //false

//        //将此 String 与另一个 String 比较,不考虑大小写。
//        boolean c1 = s1.equalsIgnoreCase(s2);
//        System.out.println(c1);    //false

//        //使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
//        byte[] c1 = s1.getBytes();
//        System.out.println(c1);    //[B@11e78461

//        //将字符从此字符串复制到目标字符数组。
//        //srcBegin -- 字符串中要复制的第一个字符的索引。 rcEnd -- 字符串中要复制的最后一个字符之后的索引。
//        //dst -- 目标数组。 dstBegin -- 目标数组中的起始偏移量。
//        //没有返回值,但会抛出 IndexOutOfBoundsException 异常。
//        //char[] s3 = new char[5];
//        s1.getChars(1,6,s3,0);
//        System.out.println(s3);    //uonin

//        //返回此字符串的哈希码。
//        int s3 = s1.hashCode();
//        System.out.println(s3);    //-1855756159

//        //返回指定字符在此字符串中第一次出现处的索引。
//        int s3 = s1.indexOf('s');
//        System.out.println(s3);    //0
//        //返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。
//        int s3 = s1.indexOf('n', 3);
//        System.out.println(s3);    //3

//        // 返回字符串对象的规范化表示形式。
//        String s3 = s1.intern();
//        System.out.println(s3);    //suoning

//        // 返回指定字符在此字符串中最后一次出现处的索引。
//        int s3 = s1.lastIndexOf('n');
//        System.out.println(s3);    //5
//        // 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
//        int s3 = s1.lastIndexOf('n', 3);
//        System.out.println(s3);    //3
//        // 返回指定子字符串在此字符串中最右边出现处的索引。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4);
//        System.out.println(s3);    //3
//        //返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4, 2);
//        System.out.println(s3);    //-1

//        //返回此字符串的长度。
//        int s3 = s1.length();
//        System.out.println(s3);    //7

//        //告知此字符串是否匹配给定的正则表达式。
//        boolean s3 = s1.matches("suo(.*)");
//        System.out.println(s3);    //true

        //测试两个字符串区域是否相等。
        //ignoreCase -- 如果为 true,则比较字符时忽略大小写。
        //toffset -- 此字符串中子区域的起始偏移量。
        //other -- 字符串参数。
        //toffset -- 字符串参数中子区域的起始偏移量。
        //len -- 要比较的字符数。
//        boolean s3 = s1.regionMatches(3, s2, 6, 4);
//        System.out.println(s3);    //false
//        boolean s3 = s1.regionMatches(true, 3, s2, 6, 4);
//        System.out.println(s3);    //false

//        //返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning

//        //返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning

//        // 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
//        String s3 = s1.replaceAll(".*", "m");
//        System.out.println(s3);    //mm

//        //使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
//        String s3 = s1.replaceFirst("n", "m");
//        System.out.println(s3);    //suoming

//        //根据给定正则表达式的匹配拆分此字符串。
//        String s5 = new String("suo ning");
//        String[] s3 = s5.split(" ", 0);
//        for (String retval: s3){
//            System.out.println(retval); //suo、ning
//        }

//        // 测试此字符串是否以指定的前缀开始。
//        boolean b1 = s1.startsWith(s2);
//        System.out.println(b1);    //false
//        //测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
//        boolean b1 = s1.startsWith(s2, 3);
//        System.out.println(b1);    //false

//        //返回一个新的字符序列,它是此序列的一个子序列。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin

//        //返回一个新的字符序列,它是此序列的一个子序列。
//        CharSequence s3 = s1.subSequence(2, 6);
//        System.out.println(s3);    //onin

//        //返回一个新的字符序列,它是此序列的一个子字符串。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin
//        String s3 = s1.substring(2);
//        System.out.println(s3);    //oning

//        //将此字符串转换为一个新的字符数组。
//        System.out.println(s1.toCharArray());    //suoning

//        //使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
//        String s3 = s1.toLowerCase();
//        System.out.println(s3);    //suoning

//        // 返回此对象本身(它已经是一个字符串!
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning

//        // 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
//        String s3 = s1.toUpperCase();
//        System.out.println(s3);    //SUONING

//        // 返回字符串的副本,忽略前导空白和尾部空白。
//        String s3 = s1.trim();
//        System.out.println(s3);    //suoning

//        // 返回给定data type类型x参数的字符串表示形式。
//        String s3 = String.valueOf(s1);
//        System.out.println(s3);    //suoning
    }
}

String practice

 

“三哥,笔者……小编怎么了?”美团被爆冷门的点名惊了一晃,不敢看老三弟的肉眼,只可以屈从轻声说道。

十一、StringBuffer & StringBuilder 类

当对字符串举办修改的时候,必要运用 StringBuffer 和 StringBuilder 类。

和 String 类不相同的是,StringBuffer 和 StringBuilder
类的对象能够被频仍的改动,并且不发生新的未选拔对象。

StringBuilder 类在 Java 5 中被建议,它和 StringBuffer 之间的最大区别在于
StringBuilder 的艺术不是线程安全的(无法一起访问)。

是因为 StringBuilder 相较于 StringBuffer
有速度优势,所以大多数状态下提出利用 StringBuilder
类。可是在应用程序须求线程安全的情形下,则必须运用 StringBuffer 类。

 

序号 方法描述
1 public StringBuffer append(String s)
将指定的字符串追加到此字符序列
2 public StringBuffer reverse()
将此字符序列用其反转形式取代
3 public delete(int start, int end)
移除此序列的子字符串中的字符
4 public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中
5 replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符
6 int capacity()
返回当前容量。
7 char charAt(int index)
返回此序列中指定索引处的 char 值。
8 void ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
9 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst
10 int indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
11 int indexOf(String str, int fromIndex)
从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。
12 int lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
13 int lastIndexOf(String str, int fromIndex)
返回最后一次出现的指定子字符串在此字符串中的索引。
14 int length()
 返回长度(字符数)。
15 void setCharAt(int index, char ch)
将给定索引处的字符设置为 ch
16 void setLength(int newLength)
设置字符序列的长度。
17 CharSequence subSequence(int start, int end)
返回一个新的字符序列,该字符序列是此序列的子序列。
18 String substring(int start)
返回一个新的 String,它包含此字符序列当前所包含的字符子序列。
19 String substring(int start, int end)
返回一个新的 String,它包含此序列当前所包含的字符子序列。
20 String toString()
返回此序列中数据的字符串表示形式。

 

法律 28法律 29

public class StringBufferBuilders {
    public static void main(String[] args){
        StringBuffer s1 = new StringBuffer("suoning");

//        //将指定的字符串追加到此字符序列。
//        String s2 = "nick";
//        StringBuffer s3 = s1.append(s2);
//        System.out.println(s3);    //suoningnick

//        //将此字符序列用其反转形式取代。
//        StringBuffer s3 = s1.reverse();
//        System.out.println(s3);    //gninous

//        //移除此序列的子字符串中的字符。
//        StringBuffer s3 = s1.delete(0, 3);
//        System.out.println(s3);    //ning

//        //将 int 参数的字符串表示形式插入此序列中。
//        StringBuffer s3 = s1.insert(3, 99);
//        System.out.println(s3);    //suo99ning

//        //使用给定 String 中的字符替换此序列的子字符串中的字符。
//        StringBuffer s3 = s1.replace(0, 3, "nick");
//        System.out.println(s3);    //nickning


//        //返回当前容量。
//        int s3 = s1.capacity();
//        System.out.println(s3);    //23

//        //返回此序列中指定索引处的 char 值。
//        char s3 = s1.charAt(3);
//        System.out.println(s3);    //n

//        //确保容量至少等于指定的最小值。
//        s1.ensureCapacity(1);
//        System.out.println(s1.capacity());    //23

//        //将字符从此序列复制到目标字符数组 dst。
//        char[] s2 = new char[4];
//        s1.getChars(3,7,s2,0);
//        System.out.println(s2);    //ning

//        //返回第一次出现的指定子字符串在该字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2);
//        System.out.println(s3);    //-1
//        //从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2, 2);
//        System.out.println(s3);    //-1

//        //返回最右边出现的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2);
//        System.out.println(s3);    //-1
//        //返回最后一次出现的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2, 3);
//        System.out.println(s3);    //-1

//        // 返回长度(字符数)。
//        int s3 = s1.length();
//        System.out.println(s3);    //7

//        //将给定索引处的字符设置为 ch。
//        s1.setCharAt(3, 'm');
//        System.out.println(s1);    //suoming

//        //设置字符序列的长度
//        s1.setLength(9);
//        System.out.println(s1.length());    //9

//        //返回一个新的字符序列,该字符序列是此序列的子序列。
//        CharSequence s3 = s1.subSequence(3, 7);
//        System.out.println(s3);    //ning

//        //返回一个新的 String,它包含此字符序列当前所包含的字符子序列。
//        String s3 = s1.substring(3);
//        System.out.println(s3);    //ning
//        //返回一个新的 String,它包含此序列当前所包含的字符子序列。
//        String s3 = s1.substring(3,7);
//        System.out.println(s3);    //ning

//        //返回此序列中数据的字符串表示形式
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning

    }
}

StringBuffer & StringBuilder
practice

 

老小叔子深吸了一口气,压住了心灵的怒火,两眼直勾勾地瞧着美团说:

十二、数组

Java 语言中提供的数组是用来囤积固定大小的同类型元素。

// 申明及创建数组
int a1[] = new int[6];    //不推荐写法,来源于C/C++
int[] a2 = new int[6];
int[] a3 = {1, 2, 3, 4, 5, 6};

数组的成分是透过索引访问的。数组索引从 0 初阶,所以索引值从 0 到
a2.length-1。

//多维数组
String s[][] = new String[5][9];
s[0][0] = new String("nick");
s[0][1] = new String("good");
s[1][0] = new String("jenny");
s[1][1] = new String("yep");
s[1][2] = new String("!");

法律 30法律 31

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

数组 practice

 

java.util.Arrays 类能方便地操作数组,它提供的持有办法都以静态的。

序号 方法和说明
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) – 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

 

法律 32法律 33

import java.util.Arrays;


public class MyArrayOfs {
    public static void main(String[] args){
        int a1[] = new int[6];
        int[] a2 = new int[6];
        int[] a3 = {1, 2, 3, 4, 5, 6};
        int[] a5 = {1, 2, 3, 9, 8, 8};
        int[] a6 = {1, 2, 3, 4, 5, 6};


//        //    public static boolean equals(long[] a, long[] a2)
//        //如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        boolean b1 = Arrays.equals(a3, a5);
//        System.out.println(b1);    //false
//        boolean b2 = Arrays.equals(a3, a6);
//        System.out.println(b2);    //true


//        //public static void fill(int[] a, int val)
//        //填充值
//        //将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        Arrays.fill(a2, 9);
//        System.out.println(a2[5]);    //9


//        //public static void sort(Object[] a)
//        //对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        Arrays.sort(a5);
//        for(int i: a5) {
//             System.out.println(i);    //1、2、3、8、8、9
//          }


//        //public static int binarySearch(Object[] a, Object key)
//        //用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
//        int index1 = Arrays.binarySearch(a5, 9);
//        System.out.println(index1);  //-7
//        Arrays.sort(a5);
//        int index2 = Arrays.binarySearch(a5, 8);
//        System.out.println(index2);  //4
//        int index3 = Arrays.binarySearch(a5, 9);
//        System.out.println(index3);  //5
    }
}

数组 practice

 

“七月份你家外卖员在送餐途中偷吃客户饭菜,吃了两口又吐回去,最终还健康配送到客户手上。你协调说,恶不恶心?咱能否有个别操守,你说您那老总怎么培养和陶冶职工的?”

十三 、Date 日期时间

java.util 包提供了 Date 类来封装当前的日期和时间。

# 实例化 Date 对象
import java.util.Date;

Date d1 = new Date();
long t1 = 1514736000000L;
Date d2 = new Date(t1);
System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018

Date 对象的法门:

序号 方法和描述
1 boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2 boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3 Object clone( )
返回此对象的副本。
4 int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5 int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6 boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7 long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8 int hashCode( )
 返回此对象的哈希码值。
9 void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10 String toString( )
转换Date对象为String表示形式,并返回该字符串。

 

法律 34法律 35

import java.util.Date;


public class DateTimes {
    public static void main(String[] args){
        Date d1 = new Date();
        long t1 = 1514736000000L;
        Date d2 = new Date(t1);
        System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018


//        //    boolean after(Date date)
//        //若当调用此方法的Date对象在指定日期之前\后返回true,否则返回false。
//        boolean b1 = d2.after(d1);
//        System.out.println(b1);  //true


//        //    int compareTo(Date date)
//        //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1


//        //    int compareTo(Object obj)
//        //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1


//        //boolean equals(Object date)
//        //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false
//        boolean b1 = d2.equals(d1);
//        System.out.println(b1);  //false


//        //    long getTime( )
//        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
//        long l1 = d2.getTime();
//        System.out.println(l1);  //1514736000000


//        //int hashCode( )
//        //返回此对象的哈希码值。
//        long l1 = d2.hashCode();
//        System.out.println(l1);  //-1387455136


//        //void setTime(long time)
//        //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
//        d1.setTime(t1);
//        System.out.println(d1);  //Mon Jan 01 00:00:00 CST 2018


//        //String toString( )
//        //转换Date对象为String表示形式,并返回该字符串。
//        d2.toString();
//        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018
    }
}

Date practice

法律 36法律 37

import java.util.Date;

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();

       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

获得当明日期时间

 

​请点击这里输入图片描述

利用DateFormat 格式化日期

面对老三哥的严刻指责,美团羞愧地恨不得在地上找个洞钻下去。而饿了么、海底捞等人却在心尖暗暗窃喜。

日子和时间更换字符

字符 描述 例子
c 完整的日期和时间 Mon May 04 09:51:52 CDT 2009
F ISO 8601 格式日期 2004-02-09
D U.S. 格式日期 (月/日/年) 02/09/2004
T 24小时时间 18:05:19
r 12小时时间 06:05:19 pm
R 24小时时间,不包含秒 18:05
Y 4位年份(包含前导0) 2004
y 年份后2位(包含前导0) 04
C 年份前2位(包含前导0) 20
B 月份全称 February
b 月份简称 Feb
m 2位月份(包含前导0) 02
d 2位日子(包含前导0) 03
e 2位日子(不包含前导0) 9
A 星期全称 Monday
a 星期简称 Mon
j 3位年份(包含前导0) 069
H 2位小时(包含前导0), 00 到 23 18
k 2位小时(不包含前导0),  0 到 23 18
I 2位小时(包含前导0), 01 到 12 06
l 2位小时(不包含前导0),  1 到 12 6
M 2位分钟(包含前导0) 05
S 2位秒数(包含前导0) 19
L 3位毫秒(包含前导0) 047
N 9位纳秒(包含前导0) 047000000
P 大写上下午标志 PM
p 小写上下午标志 pm
z 从GMT的RFC 822数字偏移 -0800
Z 时区 PST
s 自 1970-01-01 00:00:00 GMT的秒数 1078884319
Q 自 1970-01-01 00:00:00 GMT的毫妙 1078884319047

 

//使用两个字母格式,它以t开头并且以下面表格中的一个字母结尾。

import java.util.Date;
  public class DateTimes {
  public static void main(String args[]) {
      //初始化 Date 对象
      Date date = new Date();
      //使用toString()显示日期和时间
      String str = String.format("Current Date/Time : %tc", date );
      System.out.println(str);    //Current Date/Time : Sat Jan 1 00:00:00 MST 2018
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date); //Jan date: January 01, 2018
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date); //Jan date: January 01, 2018
  }
}

法律 38法律 39

//解析字符串为时间

import java.util.*;
import java.text.*;

public class DateTimes {
    public static void main(String args[]) {
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
        String input = args.length == 0 ? "2018-01-01" : args[0];
        System.out.print(input + " Parses as ");
        Date t;
        try {
          t = ft.parse(input);
          System.out.println(t);
          } catch (ParseException e) {
          System.out.println("Unparseable using " + ft);
          //2018-01-01 Parses as Mon Jan 01 00:00:00 CST 2018
        }
    }
}

解析字符串为时间

法律 40法律 41

//Java 休眠(sleep)

import java.util.*;

public class DateTimes {
    public static void main(String args[]) {
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3); // 休眠3秒
            System.out.println(new Date( ) + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }
    }
}

Java 休眠(sleep)

法律 42法律 43

//检测时间间隔(以毫秒为单位)

import java.util.*;

public class DateTimes {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         Thread.sleep(5*20*5);
         System.out.println(new Date( ) + "\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);    //Difference is : 520
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

检查和测试时间间隔

 

“对不起表哥,这个外卖员已经被本人炒掉了,笔者从此会注意严格控制食物安全和配送无污染的,有限协助不会再产生此类事件,惊扰到堂弟,笔者真是特别惭愧。”美团诚恳跟老堂弟道歉。

望着火急悔过的美团,老表哥也就不跟着说下去了,本来他还想顺便说说一月份美团职员和工人涉嫌招聘歧视的事务,想想跟这一次的核心没有太大关系,心里想:照旧下次找个日子再跟美团单独聊聊吧。

长兄边想边把头转向在两旁偷乐的海底捞,脸上刚松弛的神气,突然又起先变得沉重了。

“海底捞,你在乐呵什么?一月份您东方之珠两家店后厨出现老鼠进出食物柜,职员和工人用漏勺掏地下道、用扫垃圾的簸箕在洗碗池中洗涤。

现今那个龌龊的镜头还犹在前面,作为一家平素以劳动口碑被众人表扬的知盛名商品牌,近年来却出了那种事,你羞不羞耻?”

老二弟特意加重了小说指责海底捞,因为海底捞“老鼠门”能够算是前年在神州餐饮安全和买主权益保险方面,引起社会轰动最大的轩然大波之一。

之所以还没等海底捞说话,老四哥停顿了一下,紧接着失望地说:

“虽说你后来对该事件的公关做得没错,但你辛辛苦苦积攒这么长年累月的好口碑,近年来却差不离被八只老鼠败光了,表弟作者都替你觉得心疼。

小编能或无法从此也乐得自律些,品牌越大义务越大,那个道理你也应有懂吗?大家要对顾客承受,其余人也给自个儿竖起耳朵听着。”

海底捞自知理亏,也不敢多说一句话,只是眼眶泛红,心里既惭愧又自责。

半场又是一片静悄悄,三弟们吓得连呼吸也变得轻浅了,生怕被二哥点名。

老小弟气得拿起杯子喝了口水,杯子还没放回桌上,就扭过头对着坐在他左手的饿了么,说:

“你也是,2018年3.15就珍视揭露了您家平台存在指引商家虚构地址、上传虚假实体照片,甚至私下认可无牌照经营的黑作坊入驻等违法行为。未来整顿得怎么样呢?可不用再给小编搞工作!”

饿了么鲜明被那出其不意的诘问吓到了,缓了几秒现在,饿了么整理好思路,信心满满地回道:

“今后饿了么的违法餐厅已经全体底线,大家会三番七次严俊核对全国限制内的客栈资质,接受传播媒介和社会各界的引导和监察,努力做到以消费者为上帝!”

“行了行了,少说客套话!你、百度外卖、百胜中中原人民共和国,还有二〇一九年十二月份被百胜中中原人民共和国购回到家美味的食品会,你们都以阿里Baba(Alibaba)旗下的兄弟团,要学会互相监督,相互提升劳务档次和伙食安全。不然的话,你马老爹不丢人,笔者都替你们丢脸。”

老大哥摆了摆手,接着二个个地指了地点提到名字的这几人,“担忧”二字写在她疲惫的老脸上。

“特别是您,百胜中国,今年11月份乔治敦、圣菲波哥伦比亚大学等地接连在肯德基送出的鸡腿鸡翅下边发现了苍蝇卵和水紫黄褐活虫,出现了13分沉痛的食品卫生难点。

本身反复强调的食品质量和安全,你们全当见惯不惊了吗?都被利益蒙蔽双眼了呢?”

老三哥不依不饶地骂,气得就差一口老血喷在这群兔崽子脸上。

“还有麦当劳,近两年也每每有相近的事体时有发生。不要整天就只晓得竞争竞争,人气假使没了还谈什么商场份额。

你们这个外来食物,能打入中中原人民共和国市镇不不难,要精粹保养明日的商业信誉,不佳好做的话小心小编把你们撵回外国去。听到了吧?老M。哦不,老金。”

老大哥深深地叹了一口气,拿起桌上的杯子,一口把水喝得干干净净。百胜中中原人民共和国和金拱门同时点点头,一声不响,内心觉得愧疚。

这时,老表弟突然站了四起,淡定地从他前边放着的文件夹中腾出了一本厚厚的、凯越尺寸的书,用力地拍在了桌子的正中间,并微微扬起口角说道:

“那是本人越发为你们研商制定的《互连网餐饮食服务务食物安全监督管理措施》,新措施将于二零一八年一月二十七日起正式实施。

书中须要国内网络订餐的入网餐饮食服务务者,必须求有实体店,有食品经营的执照,必须在本身的实体店实行加工制作,不得委托任何的纳税义务人进行加工创立等。

网上所定的餐食的材质和重量要和实体店的同样,来保证消费者的活动。

待会散会你们每人在门口拿一本,回去好好研读,下次开会我要抽查背诵。小编就不行治不了你们了。散会!”

大家听得目瞪口呆,却无人敢说一声“不”。只能乖乖地站起来,灰头灰脸地朝着门口走去,各自领了一本《网络餐饮食服务务食物安全督理措施》,嘴上笑嘻嘻,心里MMP。

休会时正好是下午,我们都饿了。

于是饿了么点了份美团外卖,美团点了份饿了么,肯德基点了份麦当劳,麦当劳点了份肯德基,大家相约一同去海底捞的餐厅,用海底捞的餐具吃饭。

(完)

留下评论