一、变量与运算符
1、HelloWorld的编写和执行
class HelloChina{public static void main(String[] args){System.out.println("hello,world!!你好，中国！");}
}总结：
1. Java程序编写和执行的过程：
步骤1：编写。将Java代码编写在.java结尾的源文件中
步骤2：编译。针对于.java结尾的源文件进行编译操作。 格式：javac 源文件名.java
步骤3：运行。针对于编译后生成的字节码文件，进行解释运行。 格式： java 字节码文件名
2. 针对于步骤1的编写进行说明。
class HelloChina{
public static void main(String[] args){
System.out.println("hello,world!!你好，中国！");
}
}
其中，
① class:关键字，表示"类"，后面跟着类名。
② main()方法的格式是固定的。务必记住！表示程序的入口
public static void main(String[] args)
如果非要有些变化的话，只能变化String[] args结构。可以写成：方式1：String args[] 方式2：String[] a
args:全程是arguments，简写成args
③ Java程序，是严格区分大小写的。
④ 从控制台输出数据的操作：
System.out.println() : 输出数据之后，会换行。
System.out.print() : 输出数据之后，不会换行。
⑤ 每一行执行语句必须以;结束。
3. 针对于步骤2的编译进行说明。
① 如果编译不通过。可以考虑的问题：
问题1：查看编译的文件名、文件路径是否书写错误
问题2：查看代码中是否存在语法问题。如果存在，就可能导致编译不通过。
② 编译以后，会生成1个或多个字节码文件。每一个字节码文件对应一个Java类，并且字节码文件名与类名相同。
4. 针对于步骤3运行进行说明。
① 我们是针对于字节码文件对应的Java类进行解释运行的。
要注意区分大小写！
② 如果运行不通过。可以考虑的问题：
问题1：查看解释运行的的类名、字节码文件路径是否书写错误
问题2：可能存在运行时异常。（放到第9章中具体讲解）
5. 一个源文件中可以声明多个类，但是最多只能有一个类使用public进行声明。
且要求声明为public的类的类名与源文件名相同。
2、 单行注释和多行注释
/*
这是多行注释。
我们可以声明多行注释的信息！
1. Java中的注释的种类：
单行注释 、 多行注释 、 文档注释（Java特有）
2. 单行注释、多行注释的作用：
① 对程序中的代码进行解释说明
② 对程序进行调试
3. 注意：
① 单行注释和多行注释中声明的信息，不参与编译。换句话说，编译以后声明的字节码文件中不包含单行注释和
多行注释中的信息。
② 多行注释不能嵌套使用
4. 文档注释:
文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
*/
/**
这是我的第一个Java程序。很开森！^_^
@author shkstart
@version 1.0*/
public class CommentTest{/**这是main()方法。格式是固定的。(文档注释)*//*这是main()方法。格式是固定的。(多行注释)*/public static void main(String[] args){//这是输出语句System.out.println("hello,world!!");//System.out.println("hello,world!!")}
}3、两个案例的具体实现
案例一：
class PersonalInfo{public static void main(String[] args) {System.out.println("姓名：斯内克");System.out.println(); //换行的操作System.out.println("性别：男");System.out.println("家庭住址：北京市");}
}
案例二
class StarPrintTest {public static void main(String[] args) {System.out.println("* *");System.out.println("*\t\t*");System.out.println("*\n\n*");}
}
4、标识符
/*
测试标识符的使用
1. 什么是标识符？Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。
技巧：凡是自己可以起名字的地方都叫标识符。比如：类名、方法名、变量名、包名、常量名等
2. 标识符的命名规则 (必须要遵守！！否则，编译不通过)
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
3.标识符的命名规范(建议遵守。如果不遵守，编译和运行都能正常执行。只是容易被人鄙视)
> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
例如：java.lang、com.atguigu.bean
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
例如：HelloWorld，String，System等
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
例如：age,name,bookName,main,binarySearch,getName
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI,DEFAULT_CAPACITY
说明：大家在定义标识符时，要注意“见名知意”
*/
class IdentifierTest{public static void main(String[] args){int abc = 12;int age = 12; //age :标识符char gender = '男';char c1 = '女';//不推荐的写法//int myage = 12;//System.out.println(myage);int myAge = 12;}public static void main1(String[] args){}
}class _a$bc{
}/*
class 1abc{
}
*/class Public{
}class publicstatic{
}class BiaoShiFuTest{
}5、变量的基本使用
/*
测试变量的基本使用
1. 变量的理解：内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
2. 变量的构成包含三个要素：数据类型、变量名、存储的值
3. Java中变量声明的格式：数据类型 变量名 = 变量值
4. Java中的变量按照数据类型来分类：
基本数据类型（8种）:
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类(class)
数组(array)
接口(interface)
枚举(enum)
注解(annotation)
记录(record)
5. 定义变量时，变量名要遵循标识符命名的规则和规范。
6. 说明：
① 变量都有其作用域。变量只在作用域内是有效的，出了作用域就失效了。
② 在同一个作用域内，不能声明两个同名的变量
③ 定义好变量以后，就可以通过变量名的方式对变量进行调用和运算。
④ 变量值在赋值时，必须满足变量的数据类型，并且在数据类型有效的范围内变化。
*/
class VariableTest {public static void main(String[] args) {//定义变量的方式1：char gender; //过程1：变量的声明gender = '男'; //过程2：变量的赋值（或初始化）gender = '女';//定义变量的方式2：声明与初始化合并int age = 10;System.out.println(age);System.out.println("age = " + age);System.out.println("gender = " + gender);//在同一个作用域内，不能声明两个同名的变量//char gender = '女';gender = '男';//由于number前没有声明类型，即当前number变量没有提前定义。所以编译不通过。//number = 10;byte b1 = 127;//b1超出了byte的范围，编译不通过。//b1 = 128;}public static void main123(String[] args) {//System.out.println("gender = " + gender);char gender = '女';}
}6、整形数据类型的使用
① 声明long类型变量时，需要提供后缀。后缀为'l'或'L'
② 开发中，大家定义整型变量时，没有特殊情况的话，通常都声明为int类型。
class VariableTest1 {public static void main(String[] args) {//1.测试整型变量的使用// byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节) byte b1 = 12;byte b2 = 127;//编译不通过。因为超出了byte的存储范围//byte b3 = 128;short s1 = 1234;int i1 = 123234123;//① 声明long类型变量时，需要提供后缀。后缀为'l'或'L'long l1 = 123123123L;//② 开发中，大家定义整型变量时，没有特殊情况的话，通常都声明为int类型。
}
}7、浮点类型的使用与练习
//2.测试浮点类型变量的使用
//float \ double
double d1 = 12.3;
//① 声明long类型变量时，需要提供后缀。后缀为'f'或'F'
float f1 = 12.3f;
System.out.println("f1 = " + f1);
//② 开发中，大家定义浮点型变量时，没有特殊情况的话，通常都声明为double类型，因为精度更高。
//③ float类型表数范围要大于long类型的表数范围。但是精度不高。
//测试浮点型变量的精度
//结论：通过测试发现浮点型变量的精度不高。如果在开发中，需要极高的精度，需要使用BigDecimal类替换浮点型变量。
//测试1
System.out.println(0.1 + 0.2);
//测试2:
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);
class VariableTest1 {public static void main(String[] args) {//2.测试浮点类型变量的使用//float \ doubledouble d1 = 12.3;//① 声明long类型变量时，需要提供后缀。后缀为'f'或'F'float f1 = 12.3f;System.out.println("f1 = " + f1);//② 开发中，大家定义浮点型变量时，没有特殊情况的话，通常都声明为double类型，因为精度更高。//③ float类型表数范围要大于long类型的表数范围。但是精度不高。//测试浮点型变量的精度//结论：通过测试发现浮点型变量的精度不高。如果在开发中，需要极高的精度，需要使用BigDecimal类替换浮点型变量。//测试1System.out.println(0.1 + 0.2);//测试2:float ff1 = 123123123f;float ff2 = ff1 + 1;System.out.println(ff1);System.out.println(ff2);System.out.println(ff1 == ff2);}
}案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。
class FloatDoubleExer {public static void main(String[] args) {//定义圆周率变量double pi = 3.14;//定义三个圆的半径double radius1 = 1.2;double radius2 = 2.5;int radius3 = 6;//计算面积double area1 = pi * radius1 * radius1;double area2 = pi * radius2 * radius2;double area3 = pi * radius3 * radius3;//输出System.out.println("圆1的半径为：" + radius1 + ",面积为：" + area1);System.out.println("圆2的半径为：" + radius2 + ",面积为：" + area2);System.out.println("圆3的半径为：" + radius3 + ",面积为：" + area3);}
}
案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
class FloatDoubleExer1 {public static void main(String[] args) {double hua = 80.0;double she = (hua - 32) / 1.8;System.out.println("华氏度" + hua + "℉ 对应的摄氏度为" + she + "℃");}
}
8、字符类型的使用
class VariableTest2 {public static void main(String[] args) {//1.字符类型：char(2字节)//表示形式1：使用一对''表示，内部有且仅有一个字符char c1 = 'a';char c2 = '中';char c3 = '1';char c4 = '%';char c5 = 'γ';//编译不通过//char c6 = '';//char c7 = 'ab';//表示形式2：直接使用Unicode值来表示字符型常量。char c8 = '\u0036';System.out.println(c8);//表示形式3：使用转义字符char c9 = '\n';char c10 = '\t';System.out.println("hello" + c10 + "world");//表示形式4：使用具体字符对应的数值（比如ASCII码）char c11 = 97;System.out.println(c11);//achar c12 = '1';char c13 = 1;
}
}9、布尔类型的使用
布尔类型：boolean
① 只有两个取值：true 、 false
② 常使用在流程控制语句中。比如：条件判断、循环结构等
③ 了解：我们不谈boolean类型占用的空间大小。但是，真正在内存中分配的话，使用的是4个字节。
class VariableTest2 {public static void main(String[] args) {//2. 布尔类型：boolean//① 只有两个取值：true 、 falseboolean bo1 = true;boolean bo2 = false;//编译不通过//boolean bo3 = 0;//② 常使用在流程控制语句中。比如：条件判断、循环结构等boolean isMarried = true;if(isMarried){System.out.println("很遗憾，不能参加单身派对了");}else{System.out.println("可以多谈几个女朋友或男朋友");}//③ 了解：我们不谈boolean类型占用的空间大小。但是，真正在内存中分配的话，使用的是4个字节。}
}10、基本数据类型间的自动类型提升规则
测试基本数据类型变量间的运算规则。
1. 这里提到可以做运算的基本数据类型有7种，不包含boolean类型。
2. 运算规则包括：
① 自动类型提升
② 强制类型转换
3. 此VariableTest3.java用来测试自动类型提升
规则：当容量小的变量与容量大的变量做运算时，结果自动转换为容量大的数据类型。
byte 、short 、char ---> int ---> long ---> float ---> double
特别的：byte、short、char类型的变量之间做运算，结果为int类型。
说明：此时的容量小或大，并非指占用的内存空间的大小，而是指表示数据的范围的大小。
long(8字节) 、 float(4字节)
class VariableTest3 {public static void main(String[] args) {int i1 = 10;int i2 = i1;long l1 = i1;float f1 = l1;byte b1 = 12;int i3 = b1 + i1;//编译不通过//byte b2 = b1 + i1;//**********************************************//特殊的情况1：byte、short之间做运算byte b3 = 12;short s1 = 10;//编译不通过//short s2 = b3 + s1;i3 = b3 + s1;byte b4 = 10;//编译不通过//byte b5 = b3 + b4;//特殊的情况2：charchar c1 = 'a';//编译不通过//char c2 = c1 + b3;int i4 = c1 + b3;//**********************************************//练习1：long l2 = 123L;long l3 = 123; //理解为：自动类型提升 （int--->long）//long l4 = 123123123123; //123123123123理解为int类型，因为超出了int范围，所以报错。long l5 = 123123123123L;//此时的123123123123L就是使用8个字节存储的long类型的值//练习2：float f2 = 12.3F;//编译不通过//float f3 = 12.3; //不满足自动类型提升的规则（double --> float）。所以报错//练习3：//规定1：整型常量，规定是int类型。byte b5 = 10;//byte b6 = b5 + 1;int ii1 = b5 + 1;//规定2：浮点型常量，规定是double类型。double dd1 = b5 + 12.3;//练习4：说明为什么不允许变量名是数字开头的。为了“自洽”/*int 123L = 12;long l6 = 123L;*/}
}11、基本数据类型变量间的强制类型转换规则
规则：
1. 如果需要将容量大的变量的类型转换为容量小的变量的类型，需要使用强制类型转换
2. 强制类型转换需要使用强转符：()。在()内指明要转换为的数据类型。
3. 强制类型转换过程中，可能导致精度损失。
class VariableTest4 {public static void main(String[] args) {double d1 = 12;//自动类型提升//编译失败//int i1 = d1;int i2 = (int)d1;System.out.println(i2);long l1 = 123;//编译失败//short s1 = l1;short s2 = (short)l1;System.out.println(s2);//练习int i3 = 12;float f1 = i3;//自动类型提升System.out.println(f1); //12.0float f2 = (float)i3; //编译可以通过。只不过可以省略()而已。//精度损失的例子1：double d2 = 12.9;int i4 = (int)d2;System.out.println(i4);//精度损失的例子2：int i5 = 128;byte b1 = (byte)i5;System.out.println(b1); //-128//实际开发举例：byte b2 = 12;method(b2);long l2 = 12L;//编译不通过//method(l2);method((int)l2);}public static void method(int num){ //int num = b2;自动类型提升System.out.println("num = " + num);}
}
12、String类的基本使用
基本数据类型与String的运算
一、关于String的理解
1. String类，属于引用数据类型，俗称字符串。
2. String类型的变量，可以使用一对""的方式进行赋值。
3. String声明的字符串内部，可以包含0个，1个或多个字符。
二、String与基本数据类型变量间的运算
1. 这里的基本数据类型包括boolean在内的8种。
2. String与基本数据类型变量间只能做连接运算，使用"+"表示。
3. 运算的结果是String类型。
class StringTest {public static void main(String[] args) {String str1 = "Hello World!";System.out.println("str1");System.out.println(str1);String str2 = ""; String str3 = "a";//char c1 = 'a';//测试连接运算int num1 = 10;boolean b1 = true;String str4 = "hello";System.out.println(str4 + b1);String str5 = str4 + b1;String str6 = str4 + b1 + num1;System.out.println(str6);//hellotrue10//思考：如下的声明编译能通过吗？不能//String str7 = b1 + num1 + str4;//如何将String类型的变量转换为基本数据类型？String str8 = "abc";//不能考虑转换为基本数据类型的。int num2 = 10;String str9 = num2 + ""; //"10"//编译不通过//int num3 = (int)str9;//如何实现呢？使用Integer类。暂时大家了解。int num3 = Integer.parseInt(str9);System.out.println(num3 + 1);}
}13、String类的课后练习
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用true表示，单身用false表示）、联系方式等等。
class StringExer {public static void main(String[] args) {String name = "李进";int age = 24;char gender = '男';double weight = 130.5;boolean isMarried = false;String phoneNumber = "13012341234";String info = "name = " + name + ",age = " + age + ",gender = " + gender + ",weight = " + weight + ",isMarried = " + isMarried + ",phoneNumber = " + phoneNumber;System.out.println(info);}
}14、算术运算符的使用
*
测试运算符的使用1：算术运算符的使用
1. + - + - * / % (前)++ (后)++ (前)-- (后)-- +
除法
//除法： /int m1 = 12;int n1 = 5;int k1 = m1 / n1;System.out.println(k1);//2System.out.println(m1 / n1 * n1);//10取模
//取模（或取余）： %int i1 = 12;int j1 = 5;System.out.println(i1 % j1); //2//开发中，经常用来判断某个数num1能整除另外一个数num2。 num1 % num2 == 0//比如：判断num1是否是偶数： num1 % 2 == 0//结论：取模以后，结果与被模数的符号相同int i2 = -12;int j2 = 5;System.out.println(i2 % j2); //-2int i3 = 12;int j3 = -5;System.out.println(i3 % j3); //2int i4 = -12;int j4 = -5;System.out.println(i4 % j4); //-2a++和++a
//(前)++ :先自增1，再运算//(后)++ :先运算，后自增1int a1 = 10;int b1 = ++a1;System.out.println("a1 = " + a1 + ",b1 = " + b1); //a1 = 11,b1 = 11int a2 = 10;int b2 = a2++;System.out.println("a2 = " + a2 + ",b2 = " + b2); //a2 = 11,b2 = 10//练习1：int i = 10;//i++;++i;System.out.println("i = " + i);//11//练习2：short s1 = 10;//方式1：//编译不通过//s1 = s1 + 1;//s1 = (short)(s1 + 1);//System.out.println(s1);//方式2：s1++;System.out.println(s1);//*******************************//(前)-- :先自减1，再运算//(后)-- :先运算，再自减1//略//结论：++ 或 -- 运算，不会改变变量的数据类型！//+ :连接符，只适用于String与其他类型的变量间的运算，而且运算的结果也是String类型。15、赋值运算符的使用
//说明 += 的使用int m1 = 10;m1 += 5; //类似于m1 = m1 + 5;System.out.println(m1);byte by1 = 10;by1 += 5; //by1 = by1 + 5操作会编译报错。应该写为： by1 = (byte)(by1 + 5);System.out.println(by1);int m2 = 1;m2 *= 0.1; // m2 = (int)(m2 * 0.1)System.out.println(m2);//练习1：如何实现变量的值增加2。//方式1：int n1 = 10;n1 = n1 + 2;//方式2：推荐int n2 = 10;n2 += 2;//错误的写法：//int n3 = 10;//n3++++;//练习2：如何实现变量的值增加1。//方式1：int i1 = 10;i1 = i1 + 1;//方式2：int i2 = 10;i2 += 1;//方式3：推荐int i3 = 10;i3++; //++i3;16、比较运算符的使用
比较运算符
1. == != > < >= <= instanceof
2. 说明
① instanceof 在面向对象的多态性的位置讲解。
② == != > < >= <= 适用于基本数据类型。(细节：> < >= <=不适用于boolean类型)
运算的结果为boolean类型。
③ 了解： == != 可以适用于引用数据类型
④ 区分：== 与 =
class CompareTest {public static void main(String[] args) {int m1 = 10;int m2 = 20;boolean compare1 = m1 > m2;System.out.println(compare1);int n1 = 10;int n2 = 20;System.out.println(n1 == n2);//falseSystem.out.println(n1 = n2);//20boolean b1 = false;boolean b2 = true;System.out.println(b1 == b2);//falseSystem.out.println(b1 = b2);//true}
}17、逻辑运算符的使用
测试运算符的使用4：逻辑运算符
1. & && | || ! ^
2. 说明：
① 逻辑运算符针对的都是boolean类型的变量进行的操作
② 逻辑运算符运算的结果也是boolean类型。
③ 逻辑运算符常使用条件判断结构、循环结构中
区分：& 和 &&
1、相同点：两个符号表达的都是"且"的关系。只有当符号左右两边的类型值均为true时，结果才为true。
2、执行过程：
1）如果符号左边是true，则& 、&& 都会执行符号右边的操作
2）如果符号左边是false，则 & 会继续执行符号右边的操作
&& 不会执行符号右边的操作
3、开发中，我们推荐使用&&
boolean b1 = true;b1 = false;int num1 = 10;if(b1 & (num1++ > 0)){System.out.println("床前明月光");}else{System.out.println("我叫郭德纲");}System.out.println("num1 = " + num1);//boolean b2 = true;b2 = false;int num2 = 10;if(b2 && (num2++ > 0)){System.out.println("床前明月光");}else{System.out.println("我叫郭德纲");}System.out.println("num2 = " + num2);
区分：| 和 ||
1、相同点：两个符号表达的都是"或"的关系。只要符号两边存在true的情况，结果就为true.
2、执行过程：
1）如果符号左边是false，则| 、|| 都会执行符号右边的操作
2）如果符号左边是true，则 | 会继续执行符号右边的操作
|| 不会执行符号右边的操作
3、开发中，我们推荐使用||
boolean b3 = false;b3 = true;int num3 = 10;if(b3 | (num3++ > 0)){System.out.println("床前明月光");}else{System.out.println("我叫郭德纲");}System.out.println("num3 = " + num3);//boolean b4 = false;b4 = true;int num4 = 10;if(b4 || (num4++ > 0)){System.out.println("床前明月光");}else{System.out.println("我叫郭德纲");}System.out.println("num4 = " + num4);18、位运算符的使用
测试运算符的使用5：位运算符
1. << >> >>> & | ^ ~
2. 说明：
① << >> >>> & | ^ ~ ：针对数值类型的变量或常量进行运算，运算的结果也是数值
②
<< : 在一定范围内，每向左移动一位，结果就在原有的基础上 * 2。（对于正数、负数都适用）
>> : 在一定范围内，每向右移动一位，结果就在原有的基础上 / 2。（对于正数、负数都适用）
3. 面试题：高效的方式计算2 * 8 ？
2 << 3 或 8 << 1
class BitTest {public static void main(String[] args) {int num1 = 7;System.out.println("num1 << 1 : " + (num1 << 1));System.out.println("num1 << 2 : " + (num1 << 2));System.out.println("num1 << 3 : " + (num1 << 3));System.out.println("num1 << 28 : " + (num1 << 28));System.out.println("num1 << 29 : " + (num1 << 29));//过犹不及int num2 = -7;System.out.println("num2 << 1 : " + (num2 << 1));System.out.println("num2 << 2 : " + (num2 << 2));System.out.println("num2 << 3 : " + (num2 << 3));System.out.println(~9);System.out.println(~-10);}
}案例2：如何交换两个int型变量的值？String呢？
class BitExer {public static void main(String[] args) {int m = 10;int n = 20;System.out.println("m = " + m + ",n = " + n);//交换两个变量的值//方式1：声明一个临时变量。（推荐）//int temp = m;//m = n;//n = temp;//方式2：优点：不需要定义临时变量。 缺点：难、适用性差（不适用于非数值类型）、可能超出int的范围//m = m + n; //30 = 10 + 20;//n = m - n; //10 = 30 - 20;//m = m - n; //20 = 30 - 10;//方式3：优点：不需要定义临时变量。 缺点：真难、适用性差（不适用于非数值类型）m = m ^ n;n = m ^ n;//(m ^ n) ^ n ---> mm = m ^ n;System.out.println("m = " + m + ",n = " + n);}
}
19、条件运算符的使用
条件运算符
1. (条件表达式)? 表达式1 : 表达式2
2. 说明：
① 条件表达式的结果是boolean类型。
② 如果条件表达式的结果是true，则执行表达式1。否则，执行表达式2。
③ 表达式1 和 表达式2 需要是相同的类型或能兼容的类型。
④ 开发中，凡是可以使用条件运算符的位置，都可以改写为if-else。
反之，能使用if-else结构，不一定能改写为条件运算符。
建议，在二者都能使用的情况下，推荐使用条件运算符。因为执行效率稍高。
class ConditionTest {public static void main(String[] args) {String info = (2 > 10)? "表达式1" : "表达式2";System.out.println(info);double result = (2 > 1)? 1 : 2.0;System.out.println(result);//练习1：获取两个整数的较大值int m = 10;int n = 20;int max = (m > n)? m : n;System.out.println("较大值为：" + max);//练习2：获取三个整数的最大值int i = 20;int j = 30;int k = 23;int tempMax = (i > j)? i : j;int finalMax = (tempMax > k)? tempMax : k;System.out.println(finalMax);//合并以后的写法：不推荐int finalMax1 = (((i > j)? i : j) > k)? ((i > j)? i : j) : k;System.out.println(finalMax1);}
}练习
今天是周2，10天以后是周几？
要求：控制台输出"今天是周2，10天以后是周x"。
class ConditionExer {public static void main(String[] args) {int week = 2;//week = 4;week += 10;week %= 7;System.out.println("今天是周2，10天以后是周" + ((week == 0)? "日" : week));}
}
二、流程控制
1、if-else的基本使用
分支结构1：if-else条件判断结构
1. 格式
格式1：
if(条件表达式)｛
语句块;
｝
格式2："二选一"
if(条件表达式) {
语句块1;
}else{
语句块2;
}
格式3："多选一"
if (条件表达式1) {
语句块1;
} else if (条件表达式2) {
语句块2;
}
...
}else if (条件表达式n) {
语句块n;
} else {
语句块n+1;
}
案例1：成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则提示需要做进一步的检查
class IfElseTest {public static void main(String[] args) {/*案例1：成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则提示需要做进一步的检查。*/int heartBeats = 89;//错误的写法：if(60 <= heartBeats <= 100){if(heartBeats < 60 || heartBeats > 100){System.out.println("你需要做进一步的检查");}System.out.println("体检结束");//**********************************}
}案例2：定义一个整数，判断是偶数还是奇数
/*案例2：定义一个整数，判定是偶数还是奇数 */int num = 13;if(num % 2 == 0){System.out.println(num + "是偶数");}else{System.out.println(num + "是奇数");}案例3：
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为(80，99]时，奖励一辆山地自行车；
当成绩为[60,80]时，奖励环球影城一日游；
其它时，胖揍一顿。
说明：默认成绩是在[0,100]范围内
结论：
1. 如果多个条件表达式之间没有交集（理解是互斥关系），则哪个条件表达式声明在上面，哪个声明在下面都可以。
如果多个条件表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式的上面。否则，范围小的条件表达式不可能被执行。
class IfElseTest1 {public static void main(String[] args) {int score = 61;//方式1：/*if(score == 100){System.out.println("奖励一辆跑车");}else if(score > 80 && score <= 99){System.out.println("奖励一辆山地自行车");}else if(score >= 60 && score <= 80){System.out.println("奖励环球影城一日游");}else{System.out.println("胖揍一顿");}*///方式2：score = 88;if(score == 100){System.out.println("奖励一辆跑车");}else if(score > 80){System.out.println("奖励一辆山地自行车");}else if(score >= 60){System.out.println("奖励环球影城一日游");}else{System.out.println("胖揍一顿");}//特别的：if(score == 100){System.out.println("奖励一辆跑车");}else if(score > 80){System.out.println("奖励一辆山地自行车");}else if(score >= 60){System.out.println("奖励环球影城一日游");}/*else{System.out.println("胖揍一顿");}*/}
}2、if-else的嵌套使用
测试if-else的嵌套使用
案例：
由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。
拓展：你能实现从大到小顺序的排列吗？
1. 从开发经验上讲，没有写过超过三层的嵌套if-else结构。
2. 如果if-else中的执行语句块中只有一行执行语句，则此执行语句所在的一对{}可以省略。但是，不建议省略
class IfElseTest2 {public static void main(String[] args) {int num1 = 30;int num2 = 21;int num3 = 44;//int num1 = 30,num2 = 21,num3 = 44;if(num1 >= num2){if(num3 >= num1)System.out.println(num2 + "," + num1 + "," + num3);else if(num3 <= num2)System.out.println(num3 + "," + num2 + "," + num1);elseSystem.out.println(num2 + "," + num3 + "," + num1); //System.out.println(num2 + "," + num3 + "," + num1); }else{ // num1 < num2if(num3 >= num2){System.out.println(num1 + "," + num2 + "," + num3);}else if(num3 <= num1){System.out.println(num3 + "," + num1 + "," + num2);}else{System.out.println(num1 + "," + num3 + "," + num2);}}}
}
3、使用Scanner类从键盘获取数据
如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。
1. 使用Scanner获取不同类型数据的步骤
步骤1：导包 import java.util.Scanner;
步骤2：提供（或创建）一个Scanner类的实例
步骤3：调用Scanner类中的方法，获取指定类型的变量 (nextXxx())
步骤4：关闭资源，调用Scanner类的close()
2. 案例：小明注册某交友网站，要求录入个人相关信息。如下：
请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。
3. Scanner类中提供了获取byte \ short \ int \ long \float \double \boolean \ String类型变量的方法。
注意，没有提供获取char类型变量的方法。需要使用next().charAt(0)
//步骤1：导包 import java.util.Scanner;
import java.util.Scanner;
class ScannerTest {public static void main(String[] args) {//步骤2：提供（或创建）一个Scanner类的实例Scanner scan = new Scanner(System.in);System.out.println("欢迎光临你来我往交友网");System.out.print("请输入你的网名：");//步骤3：调用Scanner类中的方法，获取指定类型的变量String name = scan.next();System.out.print("请输入你的年龄：");int age = scan.nextInt();System.out.print("请输入你的体重："); double weight = scan.nextDouble();System.out.print("你是否单身（单身：true;不单身：false）：");boolean isSingle = scan.nextBoolean();System.out.print("请输入你的性别(男\\女)："); char gender = scan.next().charAt(0);System.out.println("网名：" + name + ",年龄: " + age + ",体重：" + weight + ",是否单身：" + isSingle + ",性别：" + gender);System.out.println("注册完成，欢迎继续进入体验！");//步骤4：关闭资源，调用Scanner类的close()scan.close();}
}
4、如何获取一个随机数
如何获取一个随机数?
1. 可以使用Java提供的API:Math类的random()
2. random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数
3. 需求1：获取一个[0,100]范围的随机整数？
需求2：获取一个[1,100]范围的随机整数？
4. 需求：获取一个[a,b]范围的随机整数？
(int)(Math.random() * (b - a + 1)) + a
class RandomTest {public static void main(String[] args) {double d1 = Math.random();System.out.println("d1 = " + d1);int num1 = (int)(Math.random() * 101); //[0.0,1.0) --> [0.0,101.0) --->[0,100]System.out.println("num1 = " + num1);int num2 = (int)(Math.random() * 100) + 1; //[0.0,1.0) --> [0.0,100.0) --->[0,99] ---> [1,100]}
}5、switch-case的基本使用
分支结构之switch-case的使用
1. 语法格式
switch(表达式){
case 常量1:
//执行语句1
//break;
case 常量2:
//执行语句2
//break;
...
default:
//执行语句2
//break;
}
2.执行过程：
根据表达式中的值，依次匹配case语句。一旦与某一个case中的常量相等，那么就执行此case中的执行语句。
执行完此执行语句之后，
情况1：遇到break，则执行break后，跳出当前的switch-case结构
情况2：没有遇到break，则继续执行其后的case中的执行语句。 ---> case 穿透
...
直到遇到break或者执行完所有的case及default中的语句，退出当前的switch-case结构
3. 说明：
① switch中的表达式只能是特定的数据类型。如下：byte \ short \ char \ int \ 枚举(JDK5.0新增) \ String(JDK7.0新增)
② case 后都是跟的常量，使用表达式与这些常量做相等的判断，不能进行范围的判断。
③ 开发中，使用switch-case时，通常case匹配的情况都有限。
④ break:可以使用在switch-case中。一旦执行此break关键字，就跳出当前的switch-case结构
⑤ default：类似于if-else中的else结构。
default是可选的，而且位置是灵活的。
4. switch-case 与if-else之间的转换
① 开发中凡是可以使用switch-case结构的场景，都可以改写为if-else。反之，不成立
② 开发中，如果一个具体问题既可以使用switch-case，又可以使用if-else的时候，推荐使用switch-case。
为什么？switch-case相较于if-else效率稍高。
class SwitchCaseTest{public static void main(String[] args){int num = 1;switch(num){case 0:System.out.println("zero");break; case 1:System.out.println("one");break; //结束当前的switch-case结构case 2:System.out.println("two");break; case 3:System.out.println("three");break; default:System.out.println("other");//break; }//另例：String season = "summer";switch (season) {case "spring":System.out.println("春暖花开");break;case "summer":System.out.println("夏日炎炎");break;case "autumn":System.out.println("秋高气爽");break;case "winter":System.out.println("冬雪皑皑");break;/*default:System.out.println("季节输入有误");break;*/}//错误的例子：编译不通过/*int number = 20;switch(number){case number > 0:System.out.println("正数");break;case number < 0:System.out.println("负数");break;default:System.out.println("零");break;}*/}
}6、switch-case的课后练习
案例：编写程序：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。
import java.util.Scanner;class SwitchCaseTest2 {public static void main(String[] args) {//1.使用Scanner，从键盘获取2023年的month、dayScanner input = new Scanner(System.in);System.out.println("请输入2023年的月份：");int month = input.nextInt();//阻塞式方法System.out.println("请输入2023年的天：");int day = input.nextInt();//假设用户输入的数据是合法的。后期我们在开发中，使用正则表达式进行校验。//2. 使用switch-case实现分支结构int sumDays = 0;//记录总天数//方式1：不推荐。存在数据的冗余/*switch(month){case 1:sumDays = day;break;case 2:sumDays = 31 + day;break;case 3:sumDays = 31 + 28 + day;break;case 4:sumDays = 31 + 28 + 31 + day;break;//...case 12:sumDays = 31 + 28 + ... + 30 + day;break;}*///方式2：switch(month){case 12:sumDays += 30;case 11:sumDays += 31;case 10:sumDays += 30;case 9:sumDays += 31;case 8:sumDays += 31;case 7:sumDays += 30;case 6:sumDays += 31;case 5:sumDays += 30;case 4:sumDays += 31;case 3:sumDays += 28; //28:2月份的总天数case 2:sumDays += 31; //31:1月份的总天数case 1:sumDays += day;//break;}System.out.println("2023年" + month + "月" + day + "日是当前的第" + sumDays + "天");input.close();//为了防止内存泄漏}
}
7、for循环结构的基本使用
循环结构之一：for循环
1. Java中规范了3种循环结构：for、while、do-while
2. 凡是循环结构，就一定会有4个要素：
① 初始化条件
② 循环条件 ---> 一定是boolean类型的变量或表达式
③ 循环体
④ 迭代部分
3. for循环的格式
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
class ForTest {public static void main(String[] args) {//需求1：题目：输出5行HelloWorld/*System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");*/for(int i = 1;i <= 50;i++){System.out.println("HelloWorld");}//此时编译不通过。因为i已经出了其作用域范围。//System.out.println(i);//需求2：int num = 1;for(System.out.print("a");num < 3;System.out.print("c"),num++){System.out.print("b");}//输出结果：abcbcSystem.out.println();//换行//需求3：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和int count = 0;//记录偶数的个数int sum = 0;//记录所有偶数的和for(int i = 1;i <= 100;i++){if(i % 2 == 0){System.out.println(i);count++;sum += i; //sum = sum + i;} }System.out.println("偶数的个数为：" + count);System.out.println("偶数的总和为：" + sum);}
}
题目：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
class ForTest1 {public static void main(String[] args) {//遍历所有的3位数for(int i = 100;i <= 999;i++){//针对于每一个三位数i，获取其各个位上数值int ge = i % 10;int shi = i / 10 % 10; //或 int shi = i % 100 / 10int bai = i / 100;//判断是否满足水仙花数的规则if(i == ge * ge * ge + shi * shi * shi + bai * bai * bai){System.out.println(i);}}}
}8、for循环结构的课后练习
案例：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
约数：12为例，约数有1,2,3,4,6,12
20为例，约数有1,2,4,5,10,20
倍数：12为例，倍数有12,24,36,48,60,72,....
20为例，倍数有20,40,60,80,....
说明：
1. 我们可以在循环结构中使用break。一旦执行break，就跳出（或结束）当前循环结构。
2. 如何结束一个循环结构？
方式1：循环条件不满足。（即循环条件执行完以后是false）
方式2：在循环体中执行了break
class ForTest2 {public static void main(String[] args) {int m = 12;int n = 20;//获取m和n中的较小值int min = (m < n)? m : n;//需求1：最大公约数//方式1：int result = 1;for(int i = 1;i <= min;i++){if(m % i == 0 && n % i == 0){//System.out.println(i);result = i;}}System.out.println(result);//方式2：推荐for(int i = min;i >= 1;i--){if(m % i == 0 && n % i == 0){System.out.println("最大公约数为：" + i);break;//一旦执行，就跳出当前循环结构。}}//需求2：最小公倍数int max = (m > n)? m : n;for(int i = max;i <= m * n;i++){if(i % m == 0 && i % n == 0){System.out.println("最小公倍数为：" + i);break;}}}
}
9、do-while 循环的使用及课后练习
循环结构之一：do-while循环
1. 凡是循环结构，就一定会有4个要素：
① 初始化条件
② 循环条件 ---> 一定是boolean类型的变量或表达式
③ 循环体
④ 迭代部分
2. do-while的格式
①
do{
③
④
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - .... - ②
3. 说明：
1) do-while循环至少执行一次循环体。
2) for、while、do-while循环三者之间是可以相互转换的。
3) do-while循环结构，在开发中，相较于for、while循环来讲，使用的较少。
class DoWhileTest {public static void main(String[] args) {//需求：遍历100以内的偶数，并输出偶数的个数和总和int i = 1;int count = 0;//记录偶数的个数int sum = 0;//记录偶数的总和do{if(i % 2 == 0){System.out.println(i);count++;sum += i;}i++;}while(i <= 100);System.out.println("偶数的个数为：" + count);System.out.println("偶数的总和为：" + sum);//***************************int num1 = 10;while(num1 > 10){System.out.println("while:hello");num1--;}int num2 = 10;do{System.out.println("do-while:hello");num2--;}while(num2 > 10);}
}
题目：模拟ATM取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。
=========ATM========
1、存款
2、取款
3、显示余额
4、退出
请选择(1-4)：
import java.util.Scanner;
class DoWhileTest1 {public static void main(String[] args) {//1. 定义balance的变量，记录账户余额double balance = 0.0;boolean flag = true; //控制循环的结束Scanner scan = new Scanner(System.in);//实例化Scannerdo{//2. 声明ATM取款的界面System.out.println("=========ATM========");System.out.println(" 1、存款");System.out.println(" 2、取款");System.out.println(" 3、显示余额");System.out.println(" 4、退出");System.out.print("请选择(1-4)：");//3. 使用Scanner获取用户的选择int selection = scan.nextInt();switch(selection){//4. 根据用户的选择，决定执行存款、取款、显示余额、退出的操作case 1:System.out.print("请输入存款的金额：");double money1 = scan.nextDouble();if(money1 > 0){balance += money1;}break;case 2:System.out.print("请输入取款的金额：");double money2 = scan.nextDouble();if(money2 > 0 && money2 <= balance){balance -= money2;}else{System.out.println("输入的数据有误或余额不足");}break;case 3:System.out.println("账户余额为：" + balance);break;case 4 :flag = false;System.out.println("感谢使用，欢迎下次光临^_^");break;default:System.out.println("输入有误，请重新输入");//break;}}while(flag);//关闭资源scan.close();}
}
9、无限循环的使用
"无限"循环结构的使用
1. 格式： while(true) 或 for(;;)
2.开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
3. 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。
class ForWhileTest {public static void main(String[] args) {/*for(;;){//while(true){System.out.println("I love you!");}*///死循环的后面不能有执行语句。//System.out.println("end");}
}案例：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
import java.util.Scanner;
class ForWhileTest1 {public static void main(String[] args) {Scanner scan = new Scanner(System.in);int positiveCount = 0;//记录正数的个数int negativeCount = 0;//记录负数的个数for(;;){//while(true){System.out.print("请输入一个整数(输入为0时结束程序)：");int num = scan.nextInt(); //获取用户输入的整数if(num > 0){ //正数positiveCount++;}else if(num < 0){ //负数negativeCount++;}else{ //零System.out.println("程序结束");break;}}System.out.println("正数的个数为：" + positiveCount);System.out.println("负数的个数为：" + negativeCount);scan.close();}
}
10、嵌套循环的使用
嵌套循环的使用
1. 嵌套循环：是指一个循环结构A的循环体是另一个循环结构B。
- 外层循环：循环结构A
- 内层循环：循环结构B
2. 说明：
1）内层循环充当了外层循环的循环体。
2）对于两层嵌套循环来说，外层循环控制行数，内层循环控制列数。
3）举例：外层循环执行m次，内层循环执行n次，则内层循环的循环体共执行m * n次
4）实际开发中，我们不会出现三层以上的循环结构，三层的循环结构都很少见。
class ForForTest {public static void main(String[] args) {//******for(int i = 1;i <= 6;i++){System.out.print('*');}System.out.println("\n##################");/********************************/for(int j = 1;j <= 5;j++){for(int i = 1;i <= 6;i++){System.out.print('*');}System.out.println();}/*i(第几行) j(每一行中*的个数)* 1 1** 2 2*** 3 3**** 4 4***** 5 5*/for(int i = 1;i <= 5;i++){for(int j = 1;j <= i;j++){System.out.print("*");}System.out.println();}/*i(第几行) j(每一行中*的个数) i + j = 7 --> j = 7 - i****** 1 6***** 2 5**** 3 4*** 4 3** 5 2* 6 1*/for(int i = 1;i <= 6;i++){for(int j = 1;j <= 7 - i;j++){System.out.print("*");}System.out.println();}/*i(第几行) j(每一行中-的个数) k(每一行中*的个数) 2*i + j = 10 --->j = 10 - 2*i
--------* 1 8 1 k = 2 * i - 1
------* * * 2 6 3
----* * * * * 3 4 5
--* * * * * * * 4 2 7
* * * * * * * * * 5 0 9* * * * * * * * * * * * * * * * *///上半部分for(int i = 1;i <= 5;i++){// -for(int j = 1;j <= 10 - 2*i;j++){System.out.print("-");}// *for(int k = 1;k <= 2 * i - 1;k++){System.out.print("* ");}System.out.println();}}
}
11、关键字break和continue的使用
1. break和continue关键字的使用
使用范围 在循环结构中的作用 相同点
break: switch-case
循环结构中 结束（或跳出）当前循环结构 在此关键字的后面不能声明执行句。
continue: 循环结构中 结束（或跳出）当次循环 在此关键字的后面不能声明执行句。
2. 了解带标签的break和continue的使用
3. 开发中，break的使用频率要远高于continue。
class BreakContinueTest{public static void main(String[] args){for(int i = 1;i <= 10;i++){if(i % 4 == 0){//break;continue;//编译不通过//System.out.println("今晚上迪丽热巴要约我！");}System.out.print(i);}System.out.println();//*****************************label:for(int j = 1;j <= 4;j++){for(int i = 1;i <= 10;i++){if(i % 4 == 0){//break;//continue; //了解//break label;//continue label;}System.out.print(i); }System.out.println();}}
}12、通过质数的输出体会算法的魅力
题目：找出100以内所有的素数（质数）？100000以内的呢？
质数：只能被1和它本身整除的自然数。比如：2,3,5,7,11,13,17,19,23,....
---> 换句话说，从2开始到这个自然数-1为止，不存在此自然数的约数。
class PrimeNumberTest {public static void main(String[] args) {/*方式1：for(int i = 2;i <= 100;i++){ //遍历100以内的自然数int number = 0; //记录i的约数的个数（从2开始，到i-1为止）//判定i是否是质数for(int j = 2;j < i;j++){if(i % j == 0){number++;}}if(number == 0){System.out.println(i);}}*///方式2：boolean isFlag = true;for(int i = 2;i <= 100;i++){ //遍历100以内的自然数//判定i是否是质数for(int j = 2;j < i;j++){if(i % j == 0){isFlag = false;}}if(isFlag){//if(isFlag == true){System.out.println(i);}//重置isFlagisFlag = true;}}
}
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此PrimeNumberTest1.java是实现方式1
class PrimeNumberTest1 {public static void main(String[] args) {//获取系统当前的时间：long start = System.currentTimeMillis();boolean isFlag = true;int count = 0;//记录质数的个数for(int i = 2;i <= 100000;i++){ //遍历100000以内的自然数//判定i是否是质数for(int j = 2;j < i;j++){if(i % j == 0){isFlag = false;}}if(isFlag){count++;}//重置isFlagisFlag = true;}//获取系统当前的时间：long end = System.currentTimeMillis();System.out.println("质数的总个数为：" + count); //9592System.out.println("花费的时间为：" + (end - start)); //7209}
}
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此PrimeNumberTest2.java是方式2，针对于PrimeNumberTest1.java中算法的优化
class PrimeNumberTest2 {public static void main(String[] args) {//获取系统当前的时间：long start = System.currentTimeMillis();boolean isFlag = true;int count = 0;//记录质数的个数for(int i = 2;i <= 100000;i++){ //遍历100000以内的自然数//判定i是否是质数for(int j = 2;j <= Math.sqrt(i);j++){if(i % j == 0){isFlag = false;break;//针对于非质数有效果。}}if(isFlag){count++;}//重置isFlagisFlag = true;}//获取系统当前的时间：long end = System.currentTimeMillis();System.out.println("质数的总个数为：" + count); //9592System.out.println("花费的时间为：" + (end - start)); //7209 -->加上break:659 -->加上Math.sqrt():6}
}三、数组
1、数组的初始化、遍历、元素的默认初始值
1. 数组的理解(Array)
概念：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
简称：多个数据的组合
Java中的容器：数组、集合框架（第12章）：在内存中对多个数据的存储。
2. 几个相关的概念
> 数组名
> 数组的元素（即内部存储的多个元素）
> 数组的下标、角标、下角标、索引、index(即找到指定数组元素所使用的编号)
> 数组的长度(即数组容器中存储的元素的个数)
3. 数组的特点：
> 数组中的元素在内存中是依次紧密排列的，有序的。
> 数组，属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以引用数据类型。
> 数组，一旦初始化完成，其长度就确定了,并且其长度不可更改。
> 创建数组对象会在内存中开辟一整块`连续的空间`。占据的空间的大小，取决于数组的长度和数组中元素的类型。
4. 复习：变量按照数据类型的分类
4.1 基本数据类型：byte \ short \ int \ long ;float \ double ; char \ boolean
4.2 引用数据类型：类、数组、接口、枚举、注解、记录
5. 数组的分类
5.1 按照元素的类型：基本数据类型元素的数组；引用数据类型元素的数组
5.2 按照数组的维数来分：一维数组；二维数组；.....
6. 一维数组的使用（6个基本点）
> 数组的声明和初始化
> 调用数组的指定元素
> 数组的属性：length,表示数组的长度
> 数组的遍历
> 数组元素的默认初始化值
> 一维数组的内存解析（难）
7. 数组元素的默认初始化值的情况
注意：以数组的动态初始化方式为例说明。
> 整型数组元素的默认初始化值：0
> 浮点型数组元素的默认初始化值：0.0
> 字符型数组元素的默认初始化值：0 (或理解为'\u0000')
> boolean型数组元素的默认初始化值：false
> 引用数据类型数组元素的默认初始化值：null
8. 一维数组的内存解析
8.1 Java中的内存结构是如何划分的？（主要关心JVM的运行时内存环境）
> 将内存区域划分为5个部分：程序计数器、虚拟机栈、本地方法栈、堆、方法区
> 与目前数组相关的内存结构： 比如：int[] arr = new int[]{1,2,3};
> 虚拟机栈：用于存放方法中声明的变量。比如：arr
> 堆：用于存放数组的实体（即数组中的所有元素）。比如：1,2,3
8.2 举例：具体一维数组的代码的内存解析
package com.atguigu1.one;/*** 一维数组的基本使用** @author 尚硅谷-宋红康* @create 12:08*/public class OneArrayTest {public static void main(String args[]) {//1. 数组的声明与初始化//复习：变量的定义格式：数据类型 变量名 = 变量值int num1 = 10;int num2; //声明num2 = 20; //初始化//1.1 声明数组double[] prices;//1.2 数组的初始化//静态初始化：数组变量的赋值与数组元素的赋值操作同时进行。prices = new double[]{20.32,43.21,43.22};// String[] foods;
// foods = new String[]{"拌海蜇","龙须菜","炝冬笋","玉兰片"};//数组的声明和初始化//动态初始化：数组变量的赋值与数组元素的赋值操作分开进行。String[] foods = new String[4];//其它正确的方式int arr[] = new int[4];int[] arr1 = {1,2,3,4}; //类型推断//错误的方式
// int[] arr2 = new int[3]{1,2,3};
// int[3] arr3 = new int[];//2. 数组元素的调用//通过角标的方式，获取数组的元素//角标的范围从0开始，到数组的长度-1结束System.out.println(prices[0]);System.out.println(prices[2]);
// System.out.println(prices[4]); //报异常：ArrayIndexOutOfBoundsExceptionfoods[0] = "拌海蜇";foods[1] = "龙须菜";foods[2] = "炝冬笋";foods[3] = "玉兰片";
// foods[4] = "酱茄子"; //报异常：ArrayIndexOutOfBoundsException//3. 数组的长度：用来描述数组容器中容量的大小//使用length属性表示System.out.println(foods.length);//4System.out.println(prices.length);//3//4. 如何遍历数组
// System.out.println(foods[0]);
// System.out.println(foods[1]);
// System.out.println(foods[2]);
// System.out.println(foods[3]);for(int i = 0;i < foods.length;i++){System.out.println(foods[i]);}for (int i = 0; i < prices.length; i++) {System.out.println(prices[i]);}}}
2、一维数组的课后练习
* 案例：输出英文星期几
*
* 用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词
* {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}
package com.atguigu1.one.exer2;import java.util.Scanner;/*** ClassName: ArrayExer02* Description:案例** 案例：输出英文星期几** 用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词* {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}** @Author 尚硅谷-宋红康* @Create 10:36* @Version 1.0*/
public class ArrayExer02 {public static void main(String[] args) {//定义包含7个单词的数组String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};//从键盘获取指定的数值，使用ScannerScanner scan = new Scanner(System.in);System.out.println("请输入数值（1-7）：");int day = scan.nextInt();//针对获取的数据进行判断即可if(day < 1 || day > 7){System.out.println("你输入的数据有误。");}else{System.out.println(weeks[day - 1]);}scan.close();}
}
* 案例2：学生考试等级划分
* <p>
* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
* 成绩>=最高分-10 等级为’A’
* 成绩>=最高分-20 等级为’B’
* 成绩>=最高分-30 等级为’C’
* 其余 等级为’D’
package com.atguigu1.one.exer3;import java.util.Scanner;/*** ClassName: ArrayExer03* Description:* 案例：学生考试等级划分* <p>* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。* 成绩>=最高分-10 等级为’A’* 成绩>=最高分-20 等级为’B’* 成绩>=最高分-30 等级为’C’* 其余 等级为’D’** @Author 尚硅谷-宋红康* @Create 10:42* @Version 1.0*/
public class ArrayExer03 {public static void main(String[] args) {//1. 从键盘输入学生的人数，根据人数，创建数组(动态初始化)Scanner scan = new Scanner(System.in);System.out.print("请输入学生人数：");int count = scan.nextInt();int[] scores = new int[count];//2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中System.out.println("请输入" + count + "个成绩");for (int i = 0; i < scores.length; i++) {scores[i] = scan.nextInt();}//3. 获取学生成绩的最大值int maxScore = scores[0];for (int i = 1; i < scores.length; i++) {if (maxScore < scores[i]) {maxScore = scores[i];}}System.out.println("最高分是：" + maxScore);//4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级for (int i = 0; i < scores.length; i++) {if (scores[i] >= maxScore - 10) {System.out.println("student " + i + " score is " + scores[i] +" grade is A");} else if (scores[i] >= maxScore - 20) {System.out.println("student " + i + " score is " + scores[i] +" grade is B");} else if (scores[i] >= maxScore - 30) {System.out.println("student " + i + " score is " + scores[i] +" grade is C");} else {System.out.println("student " + i + " score is " + scores[i] +" grade is D");}}scan.close();}
}
3、二维数组的初始化、遍历、元素的初始值
1. 二维数组的理解
- 对于二维数组的理解，可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
- 其实，从数组底层的运行机制来看，其实没有多维数组。
- 概念：数组的外层元素；数组的内层元素
2. 二维数组的使用（6个基本点）
> 数组的声明和初始化
> 调用数组的指定元素
> 数组的属性：length,表示数组的长度
> 数组的遍历
> 数组元素的默认初始化值
> 二维数组的内存解析（难）
3. 二维数组元素的默认初始化值
3.1 动态初始化方式1：(比如：int[][] arr = new int[3][4])
1）外层元素，默认存储地址值。
2）内层元素，默认与一维数组元素的不同类型的默认值规定相同。
> 整型数组元素的默认初始化值：0
> 浮点型数组元素的默认初始化值：0.0
> 字符型数组元素的默认初始化值：0 (或理解为'\u0000')
> boolean型数组元素的默认初始化值：false
> 引用数据类型数组元素的默认初始化值：null
3.2 动态初始化方式2：(比如：int[][] arr = new int[3][])
1）外层元素，默认存储null
2）内层元素，不存在的。如果调用会报错（NullPointerException）
package com.atguigu2.two;/*** 二维数组的基本使用（难点）** @author 尚硅谷-宋红康* @create 13:08*/
public class TwoArrayTest {public static void main(String[] args) {//1. 数组的声明与初始化//复习int[] arr1 = new int[]{1,2,3};//方式1：静态初始化:数组变量的赋值和数组元素的赋值同时进行int[][] arr2 = new int[][]{{1,2,3},{4,5},{6,7,8,9}};//方式2：动态初始化1:数组变量的赋值和数组元素的赋值分开进行String[][] arr3 = new String[3][4];//方式2：动态初始化2double[][] arr4 = new double[2][];//其它正确的写法：int arr5[][] = new int[][]{{1,2,3},{4,5},{6,7,8,9}};int[] arr6[] = new int[][]{{1,2,3},{4,5},{6,7,8,9}};int arr7[][] = {{1,2,3},{4,5},{6,7,8,9}}; //类型推断String arr8[][] = new String[3][4];//错误的写法
// int[][] arr9 = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};
// int[3][3] arr10 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
// int[][] arr11 = new int[][10];//2. 数组元素的调用//针对于arr2来说，外层元素{1,2,3}、{4,5}、{6,7,8,9} 内层元素：1,2,3,4,5,6,7,8,9//调用内层元素System.out.println(arr2[0][0]);//1System.out.println(arr2[2][1]);//7//调用外层元素System.out.println(arr2[0]);//[I@776ec8df//测试arr3,arr4arr3[0][1] = "Tom";System.out.println(arr3[0][1]);System.out.println(arr3[0]);//[Ljava.lang.String;@4eec7777arr4[0] = new double[4];arr4[0][0] = 1.0;//3. 数组的长度System.out.println(arr2.length);//3System.out.println(arr2[0].length);//3System.out.println(arr2[1].length);//2System.out.println(arr2[2].length);//4//4. 如何遍历数组for (int i = 0; i < arr2.length; i++) {for(int j = 0;j < arr2[i].length;j++){System.out.print(arr2[i][j] + "\t");}System.out.println();}}
}
package com.atguigu2.two;/** 二维数组的基本使用（难点） （承接TwoArrayTest.java）* * @author 尚硅谷-宋红康* @create 13:18* */public class TwoArrayTest1 {public static void main(String[] args) {//5. 数组元素的默认初始化值//以动态初始化方式1说明：int[][] arr1 = new int[3][2];//外层元素默认值：System.out.println(arr1[0]);//[I@776ec8dfSystem.out.println(arr1[1]);//[I@4eec7777//内层元素默认值：System.out.println(arr1[0][0]); //0boolean[][] arr2 = new boolean[3][4];//外层元素默认值：System.out.println(arr2[0]);//[Z@3b07d329//内层元素默认值：System.out.println(arr2[0][1]);//falseString[][] arr3 = new String[4][2];//外层元素默认值：System.out.println(arr3[0]); //[Ljava.lang.String;@41629346//内层元素默认值：System.out.println(arr3[0][1]);//null//********************************//以动态初始化方式2说明：int[][] arr4 = new int[4][];//外层元素默认值：System.out.println(arr4[0]);//null//内层元素默认值：System.out.println(arr4[0][0]);//报错// String[][] arr5 = new String[5][];
// //外层元素默认值：
// System.out.println(arr5[0]);//null
// //内层元素默认值：
// System.out.println(arr5[0][0]);//报错//6. 数组的内存解析}
}
4、数组-常见算法操作：特征值计算、数组赋值与复制
案例1：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，总和，平均值，
并输出出来。
要求：所有随机数都是两位数：[10,99]
提示：求[a,b]范围内的随机数： (int)(Math.random() * (b - a + 1)) + a;
public class ArrayExer01 {public static void main(String[] args) {//1. 动态初始化方式创建数组int[] arr = new int[10];//2. 通过循环给数组元素赋值for (int i = 0; i < arr.length; i++) {arr[i] = (int)(Math.random() * (99 - 10 + 1)) + 10;System.out.print(arr[i] + "\t");}System.out.println();//3.1 求最大值int max = arr[0];for (int i = 1; i < arr.length; i++) {if(max < arr[i]){max = arr[i];}}System.out.println("最大值为：" + max);//3.2 求最小值int min = arr[0];for (int i = 1; i < arr.length; i++) {if(min > arr[i]){min = arr[i];}}System.out.println("最小值为：" + min);//3.3 求总和int sum = 0;for (int i = 0; i < arr.length; i++) {sum += arr[i];}System.out.println("总和为：" + sum);//3.4 求平均值int avgValue = sum / arr.length;System.out.println("平均值为：" + avgValue);}
}
案例2：评委打分
分析以下需求，并用代码实现：
（1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5,4,6,8,9,0,1,2,7,3
（2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）
public class ArrayExer02 {public static void main(String[] args) {int[] scores = {5,4,6,8,9,0,1,2,7,3};//声明三个特征值int sum = 0;int max = scores[0];int min = scores[0];for (int i = 0; i < scores.length; i++) {sum += scores[i]; //累加总分//用于获取最高分if(max < scores[i]){max = scores[i];}//用于获取最低分if(min > scores[i]){min = scores[i];}}int avg = (sum - max - min) / (scores.length - 2);System.out.println("去掉最高分和最低分之后，平均分为：" + avg);}
}
案例3：使用二维数组打印一个 10 行杨辉三角。
提示：
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
public class YangHuiTest {public static void main(String[] args) {//1. 创建二维数组int[][] yangHui = new int[10][];//2.使用循环结构，初始化外层数组元素for(int i = 0;i < yangHui.length;i++){yangHui[i] = new int[i + 1];//3. 给数组的元素赋值//3.1 给数组每行的首末元素赋值为1yangHui[i][0] = yangHui[i][i] = 1;//3.2 给数组每行的非首末元素赋值//if(i >= 2){for(int j = 1;j < yangHui[i].length - 1;j++){ //j从每行的第2个元素开始，到倒数第2个元素结束yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];}//}}//遍历二维数组for (int i = 0; i < yangHui.length; i++) {for (int j = 0; j < yangHui[i].length; j++) {System.out.print(yangHui[i][j] + "\t");}System.out.println();}}
}
案例3：复制、赋值
使用简单数组
(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。
(5)打印出array1。
思考：array1和array2是什么关系？
【answer】array1和array2是两个变量，共同指向了堆空间中的同一个数组结构。即二者的地址值相同。
拓展：修改题目，实现array2对array1数组的复制
public class ArrayExer04_1 {public static void main(String[] args) {//(1)创建一个名为ArrayExer04的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。int[] array1,array2;//(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。array1 = new int[]{2,3,5,7,11,13,17,19};//(3)显示array1的内容。for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}//(4)复制array1数组给array2，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。array2 = new int[array1.length];for (int i = 0; i < array1.length; i++) {array2[i] = array1[i];}System.out.println();System.out.println(array1);System.out.println(array2);for (int i = 0; i < array2.length; i++) {if(i % 2 == 0){array2[i] = i;}}System.out.println();//换行//(5)打印出array1。for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}}
}
案例4：复制、赋值
使用简单数组
(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。
(5)打印出array1。
思考：array1和array2是什么关系？
【answer】array1和array2是两个变量，共同指向了堆空间中的同一个数组结构。即二者的地址值相同。
拓展：修改题目，实现array2对array1数组的复制
public class ArrayExer04_1 {public static void main(String[] args) {//(1)创建一个名为ArrayExer04的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。int[] array1,array2;//(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。array1 = new int[]{2,3,5,7,11,13,17,19};//(3)显示array1的内容。for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}//(4)复制array1数组给array2，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。array2 = new int[array1.length];for (int i = 0; i < array1.length; i++) {array2[i] = array1[i];}System.out.println();System.out.println(array1);System.out.println(array2);for (int i = 0; i < array2.length; i++) {if(i % 2 == 0){array2[i] = i;}}System.out.println();//换行//(5)打印出array1。for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}}
}
5、数组-常见算法操作：数组的反转、扩容、与缩容
案例：
定义数组：int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};
如何实现数组元素的反转存储？你有几种方法。
public class ArrayExer05 {public static void main(String[] args) {int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};//遍历for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}System.out.println();//反转操作//方式1：
// for(int i = 0;i < arr.length/2;i++){
// //交互arr[i] 与 arr[arr.length - 1 - i]位置的元素
// int temp = arr[i];
// arr[i] = arr[arr.length - 1 - i];
// arr[arr.length - 1 - i] = temp;
// }//方式2：for(int i = 0,j = arr.length - 1;i < j;i++,j--){//交互arr[i] 与 arr[j]位置的元素int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}//方式3：不推荐
// int[] newArr = new int[arr.length];
// for(int i = arr.length - 1;i >= 0;i--){
// newArr[arr.length - 1 - i] = arr[i];
// }// arr = newArr;//遍历for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}
案例1：数组的扩容:
现有数组 int[] arr = new int[]{1,2,3,4,5};
现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？
public class ArrayExer01_1 {public static void main(String[] args) {int[] arr = new int[]{1,2,3,4,5};//扩容1倍容量
// int[] newArr = new int[arr.length * 2];//或int[] newArr = new int[arr.length << 1];//将原有数组中的元素复制到新的数组中for (int i = 0; i < arr.length; i++) {newArr[i] = arr[i];}//将10,20,30三个数据添加到新数组中newArr[arr.length] = 10;newArr[arr.length + 1] = 20;newArr[arr.length + 2] = 30;//将新的数组的地址赋值给原有的数组变量arr = newArr;//遍历arrfor (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}案例：数组的缩容：
现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。
public class ArrayExer01_2 {public static void main(String[] args) {int[] arr={1,2,3,4,5,6,7};int deleteIndex = 4;//方式1：不新建数组
// for(int i = deleteIndex;i < arr.length - 1;i++){
// arr[i] = arr[i + 1];
// }
//
// //修改最后元素,设置为默认值
// arr[arr.length - 1] = 0;//方式2：新建数组，新的数组的长度比原有数组的长度少1个int[] newArr = new int[arr.length - 1];for (int i = 0; i < deleteIndex; i++) {newArr[i] = arr[i];}for(int i = deleteIndex;i < arr.length - 1;i++){newArr[i] = arr[i + 1];}arr = newArr;//遍历arr数组for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}
6、数组-常见算法操作：查找、冒泡排序、快速排序
排序算法的衡量标准：① 时间复杂度（最重要） ② 空间复杂度 ③ 稳定性
Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n<sup>2</sup>)＜Ο(n<sup>3</sup>)＜…＜Ο(2<sup>n</sup>)＜Ο(n!)<O(n<sup>n</sup>)
排序的分类：内部排序（内存中排序）；外部排序（外部存储设备+内存）
案例1：线性查找
定义数组：int[] arr1 = new int[]{34,54,3,2,65,7,34,5,76,34,67};
查找元素5是否在上述数组中出现过？如果出现，输出对应的索引值。
public class LinearSearchTest {public static void main(String[] args) {int[] arr1 = new int[]{34,54,3,2,65,7,34,5,76,34,67};int target = 5;
// target = 15;//查找方式：线性查找//方式1：
// boolean isFlag = true;
// for(int i = 0;i < arr1.length;i++){
// if(target == arr1[i]){
// System.out.println("找到了" + target + ",对应的位置为：" + i);
// isFlag = false;
// break;
// }
// }
//
// if(isFlag){
// System.out.println("不好意思，没有找到此元素");
// }//方式2：int i = 0;for(;i < arr1.length;i++){if(target == arr1[i]){System.out.println("找到了" + target + ",对应的位置为：" + i);break;}}顺序查找：
> 优点：算法简单；
> 缺点：执行效率低。执行的时间复杂度O(N)
案例2：二分法查找
定义数组：int[] arr2 = new int[]{2,4,5,8,12,15,19,26,37,49,51,66,89,100};
查找元素5是否在上述数组中出现过？如果出现，输出对应的索引值。
public class BinarySearchTest {public static void main(String[] args) {int[] arr2 = new int[]{2,4,5,8,12,15,19,26,37,49,51,66,89,100};int target = 5;
// target = 17;int head = 0;//默认的首索引int end = arr2.length - 1;//默认的尾索引boolean isFlag = false;//判断是否找到了指定元素while(head <= end){int middle = (head + end) / 2;if(target == arr2[middle]){System.out.println("找到了" + target + ",对应的位置为：" + middle);isFlag = true;break;}else if(target > arr2[middle]){head = middle + 1;}else{//target < arr2[middle]end = middle - 1;}}if(!isFlag){System.out.println("不好意思，未找到");}}
}
二分法查找：
> 优点：执行效率高。执行的时间复杂度O(logN)
> 缺点：算法相较于顺序查找难一点；前提：数组必须有序
案例3：使用冒泡排序，实现整型数组元素的排序操作
比如：int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};
public class BubbleSortTest {public static void main(String[] args) {int[] arr = new int[]{34,54,3,2,65,7,34,5,76,34,67};//遍历for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}//冒泡排序，实现数组元素从小到大排列for(int j = 0;j < arr.length - 1;j++){for (int i = 0; i < arr.length - 1 - j; i++) {if(arr[i] > arr[i + 1]){//交互arr[i] 和 arr[i + 1]int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;}}}System.out.println();for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}
> 冒泡排序：最简单，需要大家会手写。时间复杂度：O(n^2)
案例4：使用快速排序，实现整型数组元素的排序操作
比如：int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
public class QuickSort {public static void main(String[] args) {int[] data = {9, -16, 30, 23, -30, -49, 25, 21, 30};System.out.println("排序之前：");for (int i = 0; i < data.length; i++) {System.out.print(data[i]+" ");}quickSort(data);//调用实现快排的方法System.out.println("\n排序之后：");for (int i = 0; i < data.length; i++) {System.out.print(data[i]+" ");}}public static void quickSort(int[] data) {subSort(data, 0, data.length - 1);}private static void subSort(int[] data, int start, int end) {if (start < end) {int base = data[start];int low = start;int high = end + 1;while (true) {while (low < end && data[++low] - base <= 0);while (high > start && data[--high] - base >= 0);if (low < high) {//交换data数组[low]与[high]位置的元素swap(data, low, high);} else {break;}}//交换data数组[start]与[high]位置的元素swap(data, start, high);//经过代码[start, high)部分的元素 比[high, end]都小//通过递归调用，对data数组[start, high-1]部分的元素重复刚才的过程subSort(data, start, high - 1);//通过递归调用，对data数组[high+1,end]部分的元素重复刚才的过程subSort(data, high + 1, end);}}private static void swap(int[] data, int i, int j) {int temp = data[i];data[i] = data[j];data[j] = temp;}
}> 快速排序：最快的，开发中默认选择的排序方式；掌握快速排序的实现思路；时间复杂度：O(nlogn)
7、数组-Arrays工具类的使用与数组中常见的异常
数组工具类Arrays的使用 (熟悉)
1. Arrays类所在位置: 处在java.util包下
2. 作用：
java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
public class ArraysTest {public static void main(String[] args) {//1. boolean equals(int[] a,int[] b)：比较两个数组的元素是否依次相等int[] arr1 = new int[]{1,2,3,4,5};int[] arr2 = new int[]{1,2,3,4,5};arr2 = new int[]{1,2,3,5,4};System.out.println(arr1 == arr2);boolean isEquals = Arrays.equals(arr1,arr2);System.out.println(isEquals);//true ---> false//2. String toString(int[] a):输出数组元素信息。System.out.println(arr1); //[I@776ec8dfSystem.out.println(Arrays.toString(arr1));//3.void fill(int[] a,int val):将指定值填充到数组之中。Arrays.fill(arr1,10);System.out.println(Arrays.toString(arr1));//4. void sort(int[] a):使用快速排序算法实现的排序int[] arr3 = new int[]{34,54,3,2,65,7,34,5,76,34,67};Arrays.sort(arr3);System.out.println(Arrays.toString(arr3));//5. int binarySearch(int[] a,int key):二分查找//使用前提：当前数组必须是有序的int index = Arrays.binarySearch(arr3,15);if(index >= 0){System.out.println("找到了，索引位置为：" + index);}else{System.out.println("未找到");}}
}
1. 数组的使用中常见的异常小结
> 数组角标越界的异常：ArrayIndexOutOfBoundsException
> 空指针的异常：NullPointerException
2. 出现异常会怎样？如何处理？
> 一旦程序执行中出现了异常，程序就会终止执行。
> 针对异常提供的信息，修改对应的代码，避免异常再次出现。
角标yue'jie
public class Test {public static void main(String[] args) {
// 1. 数组角标越界的异常：int[] arr = new int[10];//角标的有效范围：0、1、2、...、9System.out.println(arr[10]);System.out.println(arr[-1]);}
}空指针异常
public class Test {public static void main(String[] args) {
// 2. 空指针异常：//情况1：int[] arr1 = new int[10];arr1 = null;System.out.println(arr1[0]);//NullPointerException}
}
public class Test {public static void main(String[] args) {
//情况2：int[][] arr2 = new int[3][];// arr2[0] = new int[10];//此行代码不存在时，下一行代码出现NullPointerExceptionSystem.out.println(arr2[0][1]); //NullPointerException}
}public class Test {public static void main(String[] args) {//情况3：String[] arr3 = new String[4];System.out.println(arr3[0].toString());//NullPointerException}
}
