黑马程序员JAVA笔记2--java基础语法

------- android培训、java培训、期待与您交流！ ----------

一、Java语言基础组成

Java语言基础由关键字、标识符、注释、常量和变量、运算符、语句、函数和数组等组成。

 

（1）关键字

关键字的定义和特点：
定义：被Java语言赋予了特殊含义的单词。
特点：关键字中所有字母都为小写。

示例：

使用编辑器 EditPlus编写一个Hello World输出程序。

编辑器中蓝色字体就是关键字，红色字体就是JDK为我们提供的类。

注释：

1、所有的关键字都不需要记忆，在后期的学习中慢慢就会掌握。

2、EditPlus默认会创建一个后缀名为bak的备份文件，如果不想创建备份文件，只需要通过如下操作： 点击Tools-->preferences-->File-->勾掉Create backup file when saving即可。

3、类名的首字母要大写，这是Java语言的命名规范之一。

4、写代码一定要遵守代码规范，注重代码的阅读性。

5、起名字一定要见明知意，例如，Abc这种名称就不要写，DemoTest则可以。

 

（2）标识符

1. 定义及特点

定义：在程序中自定义的一些名称，例如：类名。

特点：由26个英文字母大小写，数字：0-9，符号：_或$组成。

2. 定义合法标识符规则

1. 数字不可以开头，例如：2Demo就不可以。

2. 不可以使用关键字，例如：public就不可以，因为public是关键字。

3. 不可以包含“_或$”以外的特殊符号，例如：“Demo Test”就不可以，其中的空格就是特殊符号。

注释：

1、Java中严格区分大小写。

2、在起名字时，为了提高阅读性，要尽量有意义。

3、公司中经常会通过“_”代表某一类名称，例如：_temp。

       4、通过“$”分隔主名称与子名称，例如：TrafficLamp$Red。

3. Java中的名称规范

包名：多单词组成时所有字母都小写。

    例如：xxxyyyzzz

类名接口名：多单词组成时，所有单词的首字母大写。

    例如：XxxYyyZzz

变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。

    例如：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接。

    例如：XXX_YYY_ZZZ

 

（3）注释

1. 定义及特点
定义：用于注解说明解释程序的文字就是注释。
特点：提高了代码的阅读性。
2. Java中的注释格式
1. 单行注释
格式： //注释文字
2. 多行注释
格式： /*  注释文字  */
3. 文档注释
格式：/** 注释文字 */
示例：

1. /**
2. 这是我的Hello World程序。
3. @author 小强
4. */
5. class Demo
6. {
7.     /*
8.     这是主函数，是程序的入口。
9.     它的出现可以保证程序的独立运行。
10.     */
11.     public static void main(String[] args)
12.     {
13.         //这是输出语句用于将括号内的数据打印到控制台。
14.         System.out.println("Hello World");
15.     }
16. }

注释：

1、对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。所以，即使添加再多的注释，编译后生成的class文件占用硬盘字节多少不变。
2、对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
3、注释是一个程序员必须要具有的良好编程习惯。初学者编写程序必须养成习惯：先写注释再写代码。
4、将自己的思想通过注释先整理出来，再用代码去体现，因为代码仅仅是思想的一种体现形式而已。

 示例：

1. /*
2. 需求：练习一个hello world程序。
3. 思路：
4. 1. 定义一个类，因为java程序都定义在类中，java程序都是以类的形式形成的，类的形式其实就
5. 是一个字节码文件的最终体现。
6. 2. 定义一个主函数，为了让该类可以独立运行。
7. 3. 因为要演示hello world，在控制台上看到该字样，所以需要使用输出语句完成。
8. 步骤：
9. 1. 用class关键字来完成类的定义，并起一个阅读性强的类名。
10. 2. 主函数：public static void main(String[] args);，这是固定格式的，jvm认识。
11. 3. 使用输出语句：System.out.println("hello world");。
12. */
13. class Demo
14. {
15.     //定义一个主函数，为了保证程序的独立运行。
16.     public static void main(String[] args){
17.         //这是输出语句，用于将括号中的数据打印到控制台上，ln可以在数据的结尾
18. 处换行。
19.         System.out.println("hello world");
20.     }
21. }

5、单行注释可以嵌套单行注释，单行注释可以嵌套多行注释，多行注释可以嵌套单行注释。但是， 多行注释不能嵌套多行注释，因为多行注释的开头会和被嵌套的多行注释的结尾配对，导致后面的注释失 效。
6、可以使用注释对代码中的错误进行定位。
方法：

当程序运行报错时，将某些代码注释掉，然后重新编译，运行。如果程序不再报错，那么说明注释掉的部分代码中包含错误代码。

 

（4）常量

1. 定义

常量表示不能改变的数值。

2. Java中常量的分类

1. 整数常量：所有整数。

2. 小数常量：所有小数。

3. 布尔(boolean)型常量：只有两个数值，true、false。

4. 字符常量：将一个数字字母或者符号用单引号( ' ' )标识，如：'a'。

5. 字符串常量：将一个或者多个字符用双引号("")标识，如："hello world"、"a"、""（空字符串）。

6. null常量：只有一个数值就是：null。

3. 进制的由来

对于整数，有四种表现形式：

二进制：0-1，满2进1。

八进制：0-7，满8进1，用0开头表示，如：012。

十进制：0-9，满10进1。

十六进制：0-9，A-F，满16进1，用0x开头表示。如：0x4A2C。

任何数据在计算机中都是以二进制的形式存在的，二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7，超过7就进位了，这就是八进制。但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。

规律：进制越大，表现形式越短。

示例：使用计算器进行进制转换。

1. 点击“开始”-->“所有程序”-->“附件”-->“计算器”，点击“查看”-->“程序员”。

2. 在十进制下，输入1100。

3. 点击二进制，结果：10001001100

4. 点击八进制，结果：2114

5. 点击十六进制，结果：44C

4. 进制的基本转换

① 十进制转二进制：

原理：对十进制数进行除2运算。
示例：求十进制数6的二进制数。
6/2 = 3 余0
3/2 = 1 余1
1/2 = 0 余1
故，6（十进制） = 110（二进制）。

② 二进制转十进制： 
原理：二进制乘以2的过程。
示例：求二进制数110的十进制数。
110 = 0*20+1*21+1*22 = 0 + 2 + 4 = 6
示例：求二进制数00110101的十进制数。

   0      0      1     1   0   1   0   1

128    64    32    16   8   4   2   1

    -------------------------------------------------------------------------------
     = 32 * 1 + 16 * 1 + 4 * 1 + 1 * 1 = 53
示例：二进制加法，5 + 4 = 9。
        1  0  1
     + 1  0  0
     -----------------------
      1 0 0  1
③ 十进制转八进制。
原理：八进制，其实就是二进制位，3个二进制位，1个八进制位。
示例：求十进制数43的八进制数。
十进制    43
二进制    101011
三位分割 000-101-011
八进制   0  5  3
因此，43（十进制） = 101011（二进制） = 053（八进制）。
④ 十进制转十六进制。
原理：十六进制，其实就是二进制位，4个二进制位，1个十六进制位。
示例：求十进制数43的十六进制数。
十进制    43
二进制    101011
四位分割 0010-1011
十六进制 2(2) 11(B)
因此，43（十进制） = 101011（二进制） = 0x2B（十六进制）

5. 负数的进制

原理：负数的二进制表现形式就是对应的正数二进制取反加1。
示例：求-6的二进制表现形式，其实就是对应的正数6的二进制取反加1。
6
0000-0110
取反  1111-1001
加1    +0000-0001
---------------------------
1111-1010      
注释：负数 的二进制最高位永远是1。

（5）变量

1. 变量的概念
定义：内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。
特点：变量其实就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。
为什么要定义变量？
用来不断的存放同一类型的常量，并可以重复使用。
定义变量的格式：
数据类型    变量名  =  初始化值；
例如：byte b = 3;
注释：
1、格式是固定的，记住格式，以不变应万变。
2、变量的作用范围（一对{}之间有效）。
3、变量只能存放某一类型的数据。

理解：变量就如同数学中的未知数X。
2. Java语言的数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间：
        byte       1个字节
        short    2个字节
        int      4个字节
        long     8个字节
        float     4个字节
        double       8个字节
        char     2个字节
Java语言的数据类型包括8种基本类型，3种引用类型。

数据类型：

基本数据类型：

数值型：

整数类型（bate,short,int,long）

浮点类型（float，double）

字符型：（char）

布尔型：（boolean）

引用数据类型：

类（class）

接口（interface）

数组（[ ]）

注释：

1、整数默认类型：int类型，小数默认类型：double类型。
2、double类型的小数精度比float类型的小数更高。

3. 基本数据类型间的转换

1. 向上转换：

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

容量小的类型可自动转换为容量大的数据类型；

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

int i = 123;

long l = i; //自动转换，不需强转

float f = 3.14F;

double d = f;

2. 向下转换：

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

容量小的类型可自动转换为容量大的数据类型；

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

long l = 123L;

int i = (int) l;//必须强转

double d = 3.14;

Float f = (float) d;

总结：类型转化

小转大，自动！自动类型转换（也叫隐式类型转换）  

大转小，强转！强制类型转换（也叫显式类型转换）

 

（6）运算符

1. 算数运算符

符号：+、--、*、/、%、++、-- --

加号可以作为连接符使用。

整数与整数相除时，结果永远是整数，小数部分被忽略。

取模 %：

如果左边小于右边，值是左边，负数取模只考虑左边。

负数对正数取模结果为负数，正数对负数取模结果为正数。

如：3%5=3    -3/5=-3    3/-5=3

自增 ++：

++a  先自加，在使用新的a的值 ，先参与运算，再自增。

A++ 先使用a的值 ,后自加，先自增 再参与运算。

2. 赋值运算符

符号：=、+=、--=、*=、/=、%=

+= 是把左右两边的值相加后，赋值给左边只做一次运算。

在执行s+=4;语句时，编译器在编译的时候，默认进行了强制类型转换，也就是将int类型的数据转换成short类型的数据。

在执行s = s + 4;语句时，编译器在编译的时候，默认并没有强制类型转换。所以，s是short类型，4是int类型，s会自动提升为int类型，相加的和也是int类型，赋值给short类型的变量肯定会损失精度。这时候就需要进行强制类型转换：s = (short)(s + 4);。

总结 s+=4和s=s+4 的区别：

S+=4是赋值运算，只做了一次运算，而s=s+4 是做了两次运算，一次是s=4 一次是将s+4的值再赋值给s.

3. 比较运算符（关系运算符）

符号：>、>=、<、<=、!=

1、比较运算符的结果都是boolean型，也就是要么是true，要么是false。

2、比较运算符“==”不能误写成“=” 。
4. 逻辑运算符（条件运算符）

符号：&、|、^、！ 、&&、||

逻辑运算符用于连接两个boolean类型的表达式。

"&"符号的运算特点：
true & true = true;
true & false = false;
false & true = false;
false & false = false;
"&"符号运算规律：
运算的两边只要有一个是false，结果肯定是false。
只有两边都为true，结果才是true。
"|"符号的运算特点：
true | true = true;
true | false = true;
false | true = true;
false | false = false;
"|"符号运算规律：
运算的两边只要有一个是true，结果肯定是true。
只有两边都为false，结果是false。
"^"符号的运算特点：

true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
"^"符号运算规律：
^符号的两边结果如果相同，结果是false。
两边的结果不同，结果是true。

"！"符号运算规律：
!true = false
!false = true
!!true = true

"&&"符号运算规律：

和&运算的结果是一样的，但是运算过程有点小区别：

&：无论左边的运算结果是什么，右边都参与运算。
&&：当左边为false时，右边不参加运算，这样可以提升效率。
" || "符号运算规律：

和|运算的结果是一样的，但是运算过程有点小区别：

|：无论左边的运算结果是什么，右边都参与运算。
||：当左边为true时，右边不参加运算，这样可以提升效率。
注释：
使用&&和||比使用&和|更高效一些。
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

5. 位运算符

符号：<<、>>、>>>、&、|、^、~

位运算是直接对二进制位进行运算。

左移几位其实就是该数据乘以2的几次方。
<<：可以完成2的次幂运算。

右移几位其实就是该数据除以2的几次幂。
注释：

>>：对于高位出现的空位，原来高位是什么，就用什么补这个空位。
>>>：无符号右移，数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补。

用“与运算”可以很方便提取某一二进制数的其中几位数。

一个数异或同一个数两次，结果还是这个数。

注释：

利用异或运算可以实现对数据简单地进行加密，例如对一幅图片的所有数据异或3进行加密，那么这幅图片就无法查看了。解密只需要再对图片的数据执行异或3操作即可。

取反运算：

取反操作就是对二进制数值的每一位0变1，1变0。

6. 三元运算符

格式：
(条件表达式) ? 表达式1 : 表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2。

表达式：就是具有一定语法规则的语句。

 

（7）程序流程控制

1. 判断结构

if语句

格式一：

if ( 条件表达式 )
{
执行语句；
}

注释：
1、如果if语句中只有一条语句，那么可以不写大括号。不过初学者一定要写括号，以免出错。

2、如果if语句没写大括号，if就只能控制离它最近的单条语句。

格式二：

if ( 条件表达式 )
{
执行语句；
}
else
{
执行语句；
}

注释：
三元运算符就是if else语句的简写格式。
例如：b = a > 1 ? 100 : 200;就可以实现和上面同样的功能。
简写格式什么时候用？
当if else运算后，有一个具体的结果时，可以简化写成三元运算符。

格式三：
if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
注释：

if( 表达式 )后面切忌加上分号，否则表示无论表达式为true或者false，都不执行任何语句。

局部代码块：局部代码块可以定义局部变量的生命周期。

if语句特点：
1、每一种格式都是单条语句。
2、第二种格式与三元运算符的区别：三元运算符运算完一定要有值出现。好处是：可以写在其他表达式 中。
3、条件表达式无论写成什么样子，只看最终的结构是否是true或者false。

2. 选择结构

switch语句格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
switch语句特点：
1、switch语句选择的类型只有四种：byte，short，int，char。
2、case与default没有顺序。先执行第一个case，没有匹配的case执行default。
3、结束switch语句的两种情况：①遇到break，②执行到switch语句结束。
4、如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直 到遇到break或者switch结尾结束。
5、进入switch语句后，执行顺序是先执行case，然后从上到下，最后再执行default。即使default放在 case上面，执行顺序也不变。
if和switch语句的应用：
if：
1. 对具体的值进行判断。
2. 对区间判断。
3. 对运算结果是boolean类型的表达式进行判断。
switch：
1. 对具体的值进行判断。
2. 值的个数通常是固定的。
 对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率相对高。
3. 循环结构
关键词：while,do while,for。
while语句格式：
while( 条件表达式 )
{
执行语句；
}

注释：

一定要注意不要写while(x < 3);这样的语句，后面的分号就是循环体，代表不执行任何语句，这个循环就成了一个死循环。

do while语句格式：

do
{
执行语句；
}

while( 条件表达式 );

while和do while的区别：
do while语句的特点：无论条件是否满足，循环体至少执行一次。
while如果条件不满足，循环体一次都不会执行。

for语句格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；(循环体)
}

for里面的三个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

注释：

for循环的初始化表达式、循环后的操作表达式可以是多个表达式，通过逗号分隔。

例如：
for(int a = 1,b =2; a < 2 & b < 3; a++,b++)

{ }

注释：

1、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
2、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
3、在使用循环时候，一定要明确哪些语句需要参与循环，哪些不需要。循环通常情况下，需要定义条件，需要控制次数。

嵌套循环：循环里套循环

假设外循环的循环次数是m次,内循环的循环次数是n次，那么内层循环的循环次数需要 m * n次。

4. 其他流程控制语句

break语句、continue语句；

break：终止该层循环；

应用范围：选择结构和循环结构。

continue：跳过该层循环

应用范围：循环结构。

注释：

①：若这两个语句离开应用范围，存在是没有意义的。

②：这个两个语句后面都不能有语句，因为执行不到。

③：continue语句是跳过本次循环，继续下次循环。

④：标号的出现，可以让这两个语句作用于指定的循环。

 

（8）函数

1. 函数的定义

函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。
函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。

2. 函数的特点
1、定义函数可以将功能代码进行封装。
2、便于对该功能进行复用。
3、函数只有被调用才会被执行。
4、函数的出现提高了代码的复用性。
注释：
1、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在 最后一行可以省略不写，或者写上return;。
2、函数中只能调用函数，不可以在函数内部定义函数。否则，编译时期就会报错。

3、定义函数时，函数的结果应该返回给调用者，交由调用者处理。

3. 函数的应用

两个明确：

明确要定义的功能最后的结果是什么？
明确在定义该功能的过程中，是否需要未知内容参与运算。

4. 函数的重载

重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的好处：
方便于阅读，优化了程序设计。
总结：
函数的功能一样，仅仅是参与运算的未知内容不同时，可以定义多函数，却使用统一函数名称，这样方便 阅读。在调用时，虚拟机通过参数列表的不同来区分同名函数。
注释：
1、重载与返回值类型无关，只看参数列表。
2、java是严谨性语言，如果函数调用出现不确定性，会编译失败。

（9）数组

1. 数组的定义

概念：
同一种类型数据的集合。其实，数组就是一个容器。

数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
格式2：需要一个容器，存储已知的具体数据。
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
2. 数组的内存分配及特点

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
内存的划分：

1. 寄存器。

2. 本地方法区。

3. 方法区。

4. 栈内存。

5. 堆内存。
栈内存：
用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类型是false，char类型是'\u0000'。
如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。

3. 数组操作常见问题

数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。

注释：
1、直接打印数组的引用变量，打印出来的结果是数组初始地址的哈希值。

1、"[I"表示的是int类型数组，"@"后面的内容表示数组初始地址的哈希值。

4. 数组操作常见操作

对数组操作最基本的动作就是存和取。
核心思想：就是对角标的操作。

常见操作一：获取最值（最大值，最小值）

思路：

1、需要进行比较，并定义变量记录住每次比较后较大的值。

2、对数组中的元素进行遍历取出，和变量中记录的元素进行比较。

         如果遍历到的元素大于变量中记录的元素，就用变量该记录住大的值。

3、遍历结果，该变量记录就是最大值。

两个明确：

明确一：结果。是数组中的元素：int类型。

明确二：未知内容。数组。

常见操作二：排序(选择排序，冒泡排序)
选择排序
思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩 下的某个元素，就互换内容。
2、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除 第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第 二个元素就是数组中倒数第二小的元素。
3、依次类推，直到最后一个元素。

注释：
1、上面的selectSort方法之所以不用返回int数组的原因是因为：arr引用变量是对传入selectSort方 法中作为参数的数组的引用，selectSort方法执行完毕之后，我们依然可以通过arr引用变量操作传入的数 组。所以，没有必要再通过返回值获取。
2、上面的选择排序算法效率比较低，因为数组每一个元素与剩下的元素比较就是为了获得最小的元 素并且与之互换。例如：{89,34,-270,17,3,100}这个数组，第一轮就要互换4次才能使第一个元素存储的是 这个数组中最小的元素。如果是这样，那么更高效率的方式则是只需要通过两个变量，一个记录最小值， 一个记录最小值所在的角标即可。等当前元素与余下的所有元素比较完，直接互换，这样只需互换一次就 能达到目标，效率自然就会提高。

冒泡排序
思路：
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较， 如果左边的元素大于右边的元素，那么两个元素就互换。
2、经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3、第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的 元素大于右边的元素，那么两个元素就互换。
4、依照此方式，一直到只有第一和第二个元素互相比较而结束。

在真实开发中，是不可能让我们自己去写这些排序算法的，因为JDK中已经提供好了API可以直接供我们调用。

常见操作三：折半查找(二分查找)
如果一个数组是无序的，那么可以通过简单遍历查找的方式查找到某个元素所在的角标。但是如果一个数 组是有序的，那么就可以通过一种更高效的方式达到相同的目的，也就是二分查找。
思路：
1、设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标 之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标 之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时 返回-1。

注释：
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，那么这个元素的 存储的角标如何获取？
可以先通过二分查找，返回min的值，然后将待插入元素存在角标为min的数组位置，数组中角标为 min以及比min大的角标所在的数组元素全部往后顺延一个位置。

注释：
在实际开发中，二分查找也不需要我们自己去写，JDK中已经提供了相关的API供调用。

5. 数组中的数组

 二维数组[][]
格式1：
  int[][] arr = new int[3][2];
1、定义了名称为arr的二维数组。
2、二维数组中有3个一维数组。
3、每一个一维数组中有2个元素。
4、一维数组的名称分别为arr[0], arr[1], arr[2]。
5、给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;。
6、arr存储的是二维数组的初始地址，arr[0]、arr[1]、arr[2]存储的是一维数组的初始地址。
格式2：
int[][] arr = new int[3][];
二维数组中有3个一维数组，每个一维数组都是默认初始化值null，可以对这个三个一维数组分别进行初 始化。
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始 化。
第一个一维数组 arr[0] = {3,8,2};，第二个一维数组 arr[1] = {2,7};，第三个一维数组 arr[2] = {9,0,1,6};。
第三个一维数组的长度表示方式：arr[2].length;。