尚硅谷 java 2023（基础语法）笔记

一、变量与运算符

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 \ 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);
		
	}
}

案例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);//a

		char c12 = '1';
		char c13 = 1;
}
}

9、布尔类型的使用

布尔类型：boolean
① 只有两个取值：true 、 false

② 常使用在流程控制语句中。比如：条件判断、循环结构等

③ 了解：我们不谈boolean类型占用的空间大小。但是，真正在内存中分配的话，使用的是4个字节。

class VariableTest2 {
	public static void main(String[] args) {

//2. 布尔类型：boolean
		//① 只有两个取值：true 、 false
		boolean 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：char
		char 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.0

		float 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);//2

		System.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); //-2

		int i3 = 12;
		int j3 = -5;
		System.out.println(i3 % j3); //2

		int i4 = -12;
		int j4 = -5;
		System.out.println(i4 % j4); //-2
		

a++和++a

//(前)++ :先自增1，再运算
		//(后)++ :先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1); //a1 = 11,b1 = 11

		int 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);//false
		System.out.println(n1 = n2);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.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 ---> m
		m = 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);
			else
				System.out.println(num2 + "," + num3 + "," + num1);	
				//System.out.println(num2 + "," + num3 + "," + num1);	
				
		}else{ // num1 < num2
			if(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、day
		Scanner 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");

        }

		//输出结果：abcbc

		System.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 / 10
			int 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);//实例化Scanner

		do{
			//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);
			}
			
			//重置isFlag
			isFlag = 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++;
			}
			
			//重置isFlag
			isFlag = true;
		}

		//获取系统当前的时间：
		long end = System.currentTimeMillis();

		System.out.println("质数的总个数为：" + count); //9592
		System.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++;
			}
			
			//重置isFlag
			isFlag = true;
		}

		//获取系统当前的时间：
		long end = System.currentTimeMillis();

		System.out.println("质数的总个数为：" + count); //9592
		System.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]); //报异常：ArrayIndexOutOfBoundsException

		foods[0] = "拌海蜇";
		foods[1] = "龙须菜";
		foods[2] = "炝冬笋";
		foods[3] = "玉兰片";
//		foods[4] = "酱茄子"; //报异常：ArrayIndexOutOfBoundsException

		//3. 数组的长度：用来描述数组容器中容量的大小
		//使用length属性表示
		System.out.println(foods.length);//4
		System.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"};

        //从键盘获取指定的数值，使用Scanner
        Scanner 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：动态初始化2
		double[][] 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]);//1
		System.out.println(arr2[2][1]);//7

		//调用外层元素
		System.out.println(arr2[0]);//[I@776ec8df

		//测试arr3,arr4
		arr3[0][1] = "Tom";
		System.out.println(arr3[0][1]);
		System.out.println(arr3[0]);//[Ljava.lang.String;@4eec7777

		arr4[0] = new double[4];
		arr4[0][0] = 1.0;

		//3. 数组的长度
		System.out.println(arr2.length);//3
		System.out.println(arr2[0].length);//3
		System.out.println(arr2[1].length);//2
		System.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@776ec8df
		System.out.println(arr1[1]);//[I@4eec7777
		//内层元素默认值：
		System.out.println(arr1[0][0]); //0


		boolean[][] arr2 = new boolean[3][4];
		//外层元素默认值：
		System.out.println(arr2[0]);//[Z@3b07d329
		//内层元素默认值：
		System.out.println(arr2[0][1]);//false

		String[][] 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 给数组每行的首末元素赋值为1
            yangHui[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;

        //遍历arr
        for (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²)＜Ο(n³)＜…＜Ο(2ⁿ)＜Ο(n!)<O(nⁿ)

排序的分类：内部排序（内存中排序）；外部排序（外部存储设备+内存）

案例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@776ec8df

		System.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、...、9
		System.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];//此行代码不存在时，下一行代码出现NullPointerException

		System.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
    }
}