Java学习笔记

1.1 常用CMD命令

常见的CMD命令如下：

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cd itheima
cd …	回退到上一级目录。
cd 目录1\目录2…	进入多级目录。cd itheima\JavaSE
cd \	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

1.2 JDK的安装目录介绍

目录名称	说明
bin	该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。
conf	该路径下存放了JDK的相关配置文件。
include	该路径下存放了一些平台特定的头文件。
jmods	该路径下存放了JDK的各种模块。
legal	该路径下存放了JDK各模块的授权文档。
lib	该路径下存放了JDK工具的一些补充JAR包。

1.3 Java的三大平台

JavaSE、JavaME、JavaEE

1.3.1 JavaSE

是其他两个版本的基础。

1.3.2 JavaME

Java语言的小型版，用于嵌入式消费类电子设备或者小型移动设备的开发。

其中最为主要的还是小型移动设备的开发（手机）。渐渐的没落了，已经被安卓和IOS给替代了。

但是，安卓也是可以用Java来开发的。

1.3.3 JavaEE

用于Web方向的网站开发。（主要从事后台服务器的开发）

在服务器领域，Java是当之无愧的龙头老大。

1.4 Java的主要特性

• 面向对象
• 安全性
• 多线程
• 简单易用
• 开源
• 跨平台

1.4.1 Java语言跨平台的原理

• 操作系统本身其实是不认识Java语言的。
• 但是针对于不同的操作系统，Java提供了不同的虚拟机。

虚拟机会把Java语言翻译成操作系统能看得懂的语言。

1.4.2 JRE和JDK

JVM（Java Virtual Machine），Java虚拟机

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

2.1 数据类型

2.1.1 Java语言数据类型的分类

• 基本数据类型
• 引用数据类型

2.1.2 基本数据类型的四类八种

数据类型	关键字	内存占用	取值范围
整数	byte	1	负的2的7次方 ~ 2的7次方-1(-128~127)
	short	2	负的2的15次方 ~ 2的15次方-1(-32768~32767)
	int	4	负的2的31次方 ~ 2的31次方-1**(10位)**
	long	8	负的2的63次方 ~ 2的63次方-1**(19位)**
浮点数	float	4	1.401298e-45 ~ 3.402823e+38
	double	8	4.9000000e-324 ~ 1.797693e+308
字符	char	2	0-65535
布尔	boolean	1	true，false

• 没有long long数据类型

• 定义long类型变量要在数据值后加上L后缀

• 定义float类型变量要在数据值后加上F后缀

2.1.3 说明

​ e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。

​ 在java中整数默认是int类型，浮点数默认是double类型。

2.1.4 需要记忆以下几点

byte类型的取值范围：-128 ~ 127

int类型的大概取值范围：-21亿多 ~ 21亿多

整数类型和小数类型的取值范围大小关系：

​ double > float > long > int > short > byte

2.2 标识符

业内大多数程序员都在遵守阿里巴巴的命名规则。

2.2.1 硬性要求

必须要这么做，否则代码会报错。

• 必须由数字、字母、下划线_、美元符号$组成。
• 数字不能开头
• 不能是关键字
• 区分大小写的。

2.2.2 软性建议

如果不这么做，代码不会报错，但是会让代码显得比较low。

2.2.2.1 小驼峰命名法

适用于变量名和方法名

• 如果是一个单词，那么全部小写，比如：name

• 如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge

2.2.2.2 大驼峰命名法

适用于类名

• 如果是一个单词，那么首字母大写。比如：Demo、Test。

• 如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld

不管起什么名字，都要做到见名知意。

2.2.2.3 阿里巴巴命名规范细节

1. 尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。

   正确：alibaba、hangzhou、nanjing

   错误：jiage、dazhe

2. 平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。

   错误：_name

   正确：name

2.3 键盘录入

使用步骤：

• 第一步：导包

• 第二步：创建对象

• 第三步：接收数据

//1.导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;

public class ScannerDemo1{
	public static void main(String[] args){
        
		//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
		Scanner sc = new Scanner(System.in);
        
		//3.接收数据
		int i = sc.nextInt();
        
		System.out.println(i);
	}
}

2.4 IDEA中层级结构介绍

2.4.1 结构分类

• project（项目、工程）
• module（模块）
• package（包）
• class（类）

2.4.2 结构介绍

2.4.2.1 project（项目、工程）

​ 淘宝、京东、黑马程序员网站都属于一个个项目，IDEA中就是一个个的Project。

2.4.2.2 module（模块）

​ 在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。在黑马程序员的官方网站中，至少包含了以下模块：

• 论坛模块
• 报名、咨询模块

为了更好的管理代码，我们会把代码分别放在两个模块中存放。

2.4.2.3 package（包）

​ 一个模块中又有很多的业务，以黑马程序员官方网站的论坛模块为例，至少包含了以下不同的业务。

• 发帖
• 评论

为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。

2.4.2.4 class（类）

​ 就是真正写代码的地方。

2.4.3 小结

• 层级关系

  ​ project - module - package - class

• 包含数量

  ​ project中可以创建多个module
  ​ module中可以创建多个package
  ​ package中可以创建多个class

  ​ 这些结构的划分，是为了方便管理类文件的。

3.1隐式转换

3.1.1 概念

​ 也叫自动类型提升。

​ 就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。

3.1.2 简单记忆

​ 就是小的给大的，可以直接给。

3.1.3 两种提升规则

• 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
• byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。

3.1.4 取值范围从小到大的关系

​ byte<short<int<long<float<double

3.1.4.1 案例一

double d = 10;
System.out.println(d);//10.0

解释：

​ 10是整数，整数默认是int类型的。

​ 在赋值的时候把一个int类型的赋值给了一个double类型的。把一个小的赋值给一个大的是可以直接给的。

3.1.4.2 案例二

byte b1 = 10;
byte b2 = 20;
??? result = b1 + b2;//int
问变量result是什么类型的？

解释：因为b1和b2都是byte类型的。所以在参与计算的时候，变量b1和变量b2里面的值都会自动提升为int类型的。最终其实就是两个int类型的相加，最终结果也是int类型的。

3.2 强制转换

3.2.1 概念

​ 如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。

​ 如果一定要这么干，就需要加入强制转换。

3.2.2 书写格式

​ 目标数据类型 变量名 = （目标数据类型）被强转的数据；

简单理解：

​ 要转成什么类型的，那么就在小括号中写什么类型就可以了。

案例

public class OperatorDemo2 {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b);//12
    }
}

注意点：

​ 强制转换有可能会导致数据发生错误。（数据的精度丢失）

3.3 字符串的+操作

3.3.1 核心技巧

• 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
• 当连续进行+操作时，从左到右逐个执行的。

案例

1 + 2 + "abc" + 2 + 1

结果：“3abc21”

3.4 字符的+操作

3.4.1 规则

​ 当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

案例

char c = 'a';
int result = c + 0;
System.out.println(result);//97

ASCII码表中：

​ ‘a’ ----- 97

​ ‘A’ ----- 65

3.5 自增自减运算符

++  自增运算符
--  自减运算符

使用方式

• 放在变量的前面，我们叫做先++。 比如：++a
• 放在变量的后面，我们叫做后++。 比如：a++

int a = 10;
int b = a++;  //b=10,a=11
int c = ++a;  //c=12,a=12

3.6 扩展赋值运算符

3.6.1 分类

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

3.6.2 运算规则

​ 就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

3.6.3 注意

​ 扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        a += b;
        System.out.println(a);//30
    }
}

a += b ;实际上相当于 a = (byte)(a + b);

3.7 逻辑运算符

& 和 | 的使用

&：逻辑与（而且）

• 需要同时满足左边和右边两种情况时
• 两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

• 两个条件中，只要满足其中一个
• 两边都为假，结果才是假，只要有一个为真，那么结果就是真。

3.8 短路逻辑运算符

3.8.1 分类： && ||

&&：

​ 运算结果跟&是一模一样的，只不过具有短路效果。

||：

​ 运算结果跟|是一模一样的。只不过具有短路效果。

3.8.2 逻辑核心

​ 当左边不能确定整个表达式的结果，右边才会执行。

​ 当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。

3.9 三元运算符

又叫做：三元表达式或者问号冒号表达式。

3.9.1 格式

​ 关系表达式 ？ 表达式1 ：表达式2 ；

3.9.2 计算规则

• 计算关系表达式的值。
• 如果关系表达式的值为真，那么执行表达式1。
• 如果关系表达式的值为假，那么执行表达式2。

3.9.3 注意点

​ 三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

4.1 流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

4.1.1 流程控制语句分类

​ 顺序结构

​ 判断和选择结构(if, switch)

​ 循环结构(for, while, do…while)

4.1.1.1 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行.

4.1.1.2 判断和选择结构

if语句格式1:

if (关系表达式) {
    语句体;	
}

if语句格式2:

if (关系表达式) {
    语句体1;	
} else {
    语句体2;	
}

if语句格式3:

if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

switch语句:

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

switch的扩展知识

• default的位置和省略情况

  default可以放在任意位置，也可以省略

• case穿透

  不写break会引发case穿透现象

4.1.1.3 循环结构

for循环格式：

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

• 如果是false，循环结束

• 如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

while循环格式:

初始化语句;
while(条件判断语句){
	循环体;
	条件控制语句;
}

do…while循环格式:

初始化语句;
do{
    循环体;
    条件控制语句;
}while(条件判断语句);

特点：先执行，再判断。

三种格式的区别

• for和while循环，是先判断，再执行。

• do…while是先执行，再判断。

• 当知道循环次数或者循环范围的时候，用for循环。

• 当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。

5.1 无限循环

5.1.1 概念

又叫死循环。循环一直停不下来。

5.1.1.1 for格式

for(;;){
    System.out.println("循环执行一直在打印内容");
}

解释：

• 初始化语句可以空着不写，表示循环之前不定义任何的控制变量。

• 条件判断语句可以空着不写，如果不写，默认表示true，循环一直进行。

• 条件控制语句可以空着不写，表示每次循环体执行完毕后，控制变量不做任何变化。

5.1.1.2 while格式

while(true){
    System.out.println("循环执行一直在打印内容");
}

5.1.1.3 do…while格式

do{
    System.out.println("循环执行一直在打印内容");
}while(true);

5.2 条件控制语句

• break
• continue

5.2.1 break

不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。

5.2.2 continue

不能单独存在的。只能存在于循环当中。

表示：跳过本次循环，继续执行下次循环。

5.3 Random

使用步骤：

• 导包
• 创建对象
• 生成随机数

//1.导包
import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {
        
        //2.创建对象
        Random r = new Random();
        
        //3.生成随机数
        int number = r.nextInt(100);//包左不包右，包头不包尾
        
        //0 ~ 99
        System.out.println(number);

    }
}

5.4 数组

5.4.1 概念

• 指的是一种容器，可以同来存储同种数据类型的多个值。

• 但是数组容器在存储数据的时候，需要结合隐式转换考虑。

• 比如：定义了一个int类型的数组。那么boolean,double类型的数据是不能存到这个数组中的，但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

• 建议：容器的类，和存储的数据类型保持一致。

• 举例：

  • 整数1 2 3 4 56 就可以使用int类型的数组来存储。
  • 小数1.1 1.2 1.3 1.4 就可以使用double类型的数组来存储。
  • 字符串"aaa" “bbb” “ccc” 就可以使用String类型的数组来存储。

5.4.2 数组的定义

5.4.2.1 格式一

数据类型 [] 数组名 , 比如：int [] array

5.4.2.2 格式二

数据类型 数组名 [] , 比如： int array []

5.4.3 数组的静态初始化

5.4.3.1 完整格式

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4…};

比如:

int[] arr = new int[]{11,22,33};

double[] arr = new double[]{1.1,1.2,1.3};

5.4.3.2 格式详解

数据类型：限定了数组以后能存什么类型的数据。

方括号：表示现在定义的是一个数组。

数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。

• arr namesArr

new：就是给数组在内存中开辟了一个空间。

数据类型：限定了数组以后能存什么类型的数据。前面和后面的数据类型一定要保持一致。

• int[] arr = new double[]{11,22,33};//错误写法

public class test19 {
    public static void main(String[] args) {
        double[] arr={11,22,33};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

运行结果为:

11.0
22.0
33.0

方括号：表示现在定义的是一个数组。

大括号：表示数组里面的元素。元素也就是存入到数组中的数据。多个元素之间，一定要用逗号隔开。

注意点：

• 等号前后的数据类型必须保持一致。
• 数组一旦创建之后，长度不能发生变化。

5.4.3.3 简化格式

数据类型[] 数组名 = {元素1，元素2，元素3，元素4…};

比如：

int[] array = {1,2,3,4,5};

double[] array = {1.1,1.2,1.3};

5.4.4 地址值

int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736

double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2

• 打印数组的时候，实际出现的是数组的地址值。

• 数组的地址值：就表示数组在内存中的位置。

• 以[I@6d03e736为例：

  • [ ：表示现在打印的是一个数组。
  • I：表示现在打印的数组是int类型的。
  • @：仅仅是一个间隔符号而已。
  • 6d03e736：就是数组在内存中真正的地址值。（十六进制）
    • 但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。

5.4.5 数组的动态初始化

5.4.5.1 格式

数据类型[] 数组名 = new 数据类型[数组的长度];

比如:

//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];


//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];

5.4.5.2 数组的默认初始化值

• 整数类型：0

• 小数类型：0.0

• 布尔类型：false

• 字符类型：‘\u0000’ 表现为空格

• 引用类型：null

6.1 方法

方法（method）是程序中最小的执行单元

• 注意：
  • 方法必须先创建才可以使用，该过程成为方法定义
  • 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

6.1.1 方法的定义和调用

6.1.1.1 无参数方法定义和调用

定义格式：

public static void 方法名 (   ) {
	// 方法体;
}

调用格式：

方法名();

6.1.1.2 带参数方法定义和调用

定义格式：

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

调用格式：

方法名(参数)；

方法名(参数1,参数2);

6.1.2 形参和实参

• 形参：方法定义中的参数

  • 等同于变量定义格式，例如：int number

• 实参：方法调用中的参数

  • 等同于使用变量或常量，例如： 10 number

6.1.3 带返回值方法的定义和调用

定义格式:

public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

调用格式:

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

• 方法的返回值通常会使用变量接收，否则该返回值将无意义

6.1.4 方法的注意事项

• 方法不能嵌套定义
• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

6.1.5 方法重载

• 方法重载概念

  方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

  • 多个方法在同一个类中
  • 多个方法具有相同的方法名
  • 多个方法的参数不相同 — 类型不同或者数量不同

• 注意：

  • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
  • 重载仅针对同一个类中方法的名称与参数 进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

正确范例:

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

public class MethodDemo {
	public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

错误范例:

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/
    	//方法体
    }
 

public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) {   /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

7.1 类

• 类的理解

  • 类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
  • 简单理解：类就是对现实事物的一种描述

• 类的组成

  • 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
  • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

• 类和对象的关系

  • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 对象：是能够看得到摸的着的真实存在的实体
  • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

注意：

类名首字母大写，见名知意，驼峰命名

一个java文件可以定义多个class类，只有一个类是public修饰，而且public修饰的类名同时也是class文件名

实际开发中：一个类一个文件

7.1.1 类的定义步骤

①定义类

②编写类的成员变量

③编写类的成员方法

7.1.2 成员变量和局部变量的区别

• 类中位置不同：
  • 成员变量：类中方法外
  • 局部变量：方法内部或方法声明上
• 内存中位置不同：
  • 成员变量：堆内存
  • 局部变量：栈内存
• 生命周期不同：
  • 成员变量：随着对象的存在而存在，随着对象的消失而消失
  • 局部变量：随着方法的调用而存在，醉着方法的调用完毕而消失
• 初始化值不同：
  • 成员变量：有默认初始化值
  • 局部变量：没有默认初始化值，必须先定义，赋值才能使用

public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

7.1.3 创建对象的格式

类名 对象名 = new 类名();

• 调用成员的格式：
  • 对象名.成员变量
  • 对象名.成员方法()

public class Cjm {
    //成员变量
    String name;
    int age;

    //成员方法
    public void cjm1() {
        System.out.println("cjm是大傻逼");
    }

    public void cjm2() {
        System.out.println("cjm是大聪明");
    }
}
/*
测试类
*/
public class CjmDemo {
    public static void main(String[] args) {
        //创建对象
        Cjm s = new Cjm();

        s.name = "cjm";
        s.age = 22;
		
         //使用对象
        System.out.println(s.name + "," + s.age);

        s.cjm1();
        s.cjm2();
    }
}

7.2 封装

7.2.1 封装思想

• 封装概述：是面向对象三大特征之一（封装，继承，多态）
• 对象代表什么，就得封装对应的数据，并提供数据对应的行为
• 封装代码实现：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法

7.2.2 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的

操作：

• 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

• 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

public class Cjm {
    private int age;
    
    public void setAge(int a){
        if(a>=14&&a<=50){
            age=a;
        }else{
            System.out.println("非法数值");
        }
    }
    public int getAge(){
        return age;
    }
}

import java.util.Scanner;

public class CjmTest {
    public static void main(String[] args) {
        Cjm cjm = new Cjm();
        Scanner sc=new Scanner(System.in);
        int age= sc.nextInt();
        cjm.setAge(age);
        System.out.println("年龄为："+cjm.getAge());
    }
}

8.1 API

API (Application Programming Interface) ：应用程序编程接口

java中的API指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，不需要关心这些类

是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

8.2 String类

• String是Java定义好的的一个类，定义在java.lang包中，使用时不需要导包
• Java程序中所有的字符串文字，例如"abc"，都为此类的对象
• 字符串不可变，创建后不能被修改

常用的构造方法：

方法名	说明
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象

public static void main(String[] args) {
        //直接赋值
        String str="cjm是大傻逼";
        System.out.println(str);
        
        //创建空字符串
        String str1=new String();  //""
        System.out.println("cjm"+str1+"是大傻逼");
        
        //参数传递创建字符串
        String str3=new String("cjm是大傻逼");
        System.out.println(str3);
        
        //传递一个字符数组创建字符串
        //需求：修改字符串
        char[] ch={'c','j','m','是','大','傻','逼'};
        String str4=new String(ch);
        System.out.println(str4);
        
        //传递字节数组，将字节信息转化成字符串
        byte[] chs={99,98,100,101};
        String str5=new String(chs);
        System.out.println(str5);  //cbde
    }

java内存图:

直接赋值型内存图：

**注意：**当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在：

• 不存在：创建新的字符串
• 存在：复用

new创建字符串内存图：

**注意：**通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

8.2.1 字符串的比较

==== 的实质：==

• 基本数据类型比较的是数据值
• 引用数据类型比较的是地址值

字符串的比较：

str1.equals(str2);  //完全一样才是true,否则为false
str1.equalsIgnoreCase(str2);  //忽略大小写

!!!注意：键盘录入的字符串是new出来的，存在堆里面

Scanner sc=new Scanner(System.in);
String str=sc.next();

练习：已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

import java.util.Scanner;

public class test23 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String rightUsername="cjm";
        String rightPassword="1234";
        int count1=0;
        int count2=0;
        int flag=0;
        System.out.println("请输入您的用户名：");
        while(true){
            if(flag==1){
                break;
            }
            String inputUserNum= sc.next();
            if(inputUserNum.equals(rightUsername)){
                System.out.println("请输入您的密码：");
                while(true){
                    String password= sc.next();
                    if(password.equals(rightPassword)){
                        flag=1;
                        System.out.println("登录成功！");
                        break;
                    }else{
                        count2++;
                        if(count2<3){
                            System.out.println("密码输入错误！请重新输入：");
                        }else{
                            System.out.println("您的账户被锁定！登录失败！");
                            flag=1;
                            break;
                        }
                    }
                }
            }else{
                count1++;
                if(count1<3){
                    System.out.println("用户名输入错误！请重新输入：");
                }else{
                    System.out.println("登录失败！");
                    break;
                }
            }
        }
    }
}

8.2.2 字符串索引和长度

public class test24 {
    public static void main(String[] args) {
        String str="cjm是大傻逼";
        //str.length();
        System.out.println(str.length());
        
        for (int i = 0; i < str.length(); i++) {
            System.out.print(str.charAt(i)+" ");
        }
        
    }
}

区别：获得数组的长度

char[] ch={'c','j','m','是','大','傻','逼'};
System.out.println(ch.length);

8.2.3 字符串练习

练习1：统计不同字符出现的次数

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

import java.util.Scanner;

public class test25 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();  //ctrl + alt + V 自动生成左边的接受变量
        
        int bigNum = 0;
        int smallNum = 0;
        int num = 0;
        
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c >= 'a' && c <= 'z') {
                smallNum++;
            } else if (c >= 'A' && c <= 'Z') {
                bigNum++;
            } else if(c>='0'&&c<='9'){
                num++;
            }
        }
        
        System.out.println("该字符串中大写字母字符出现的次数为："+bigNum);
        System.out.println("该字符串中小写字母字符出现的次数为："+smallNum);
        System.out.println("该字符串中数字字符字符出现的次数为："+num);
    }
}

练习2：字符串拼接

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。

例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

package Code;

public class test26 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        String s=connect(arr);
        System.out.print(s);
    }
    public static String connect(int[] arr){
        if(arr==null){
            return "";
        }
        if(arr.length==0){
            return "[]";
        }
        else{
            String result="[";
            for (int i = 0; i < arr.length; i++) {
                if(i==arr.length-1){
                    result=result+arr[i]+"]";
                }else{
                   result=result+arr[i]+",";
                }
            }
            return result;
        }
    }
}

报错：problem：String concatenation ‘+’ in loop

String str="";
for(int i=0;i<10;i++){
	str+="a";
}
str=str+"a"+"b";

//反编译后，实质：

String str = "";
for(int i = 0; i < 10; i++){
    str = (new StringBuilder()).append(str).append("a").toString();
}	
str = (new StringBuilder()).append(str).append("a").append("b").toString();

在for循环中，每次都是new了一个StringBuilder，然后再把String转成StringBuilder，再进行append。

而频繁的新建对象耗费很多时间，还会造成内存资源的浪费。

在for循环外写str=str+"a"+"b";，是为了告诉大家，不是一个”+“就创建一个StringBuilder

结论：

1. 如果不是在循环体中进行字符串拼接的话，直接使用+就好了。
2. 如果在并发场景中进行字符串拼接的话，要使用StringBuffer来代替StringBuilder。

练习3：字符串反转

//import com.sun.org.apache.xpath.internal.operations.String;
//String报错，将误导入的包删除

import java.util.Scanner;

public class test27 {
    
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str= sc.next();
        System.out.println(reverseString(str));
    }
    
    public static String reverseString(String str){
        String result="";
        for (int i = str.length()-1; i>=0; i--) {
            result=result+str.charAt(i);
        }
        return result;
    }
}

练习4：金额转换

把2135变成：零佰零拾零万贰仟壹佰叁拾伍元

把789变成：零佰零拾零万零仟柒佰捌拾玖元

package Code;

import java.util.Scanner;

public class test28 {
    public static void main(String[] args) {
        String[] str1={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};  //数字
        String[] str2={"佰","拾","万","仟","佰","拾","元"};  //单位
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入数字(最长7位)：");
        int num= sc.nextInt();
        //将数字进行拆分
        String result="";  //大写数字字符串
        int count=0; //记录数字位数
        while(num!=0){
            int a=num%10;
            result=str1[a]+result;
            num=num/10;
            count++;
        }
        //System.out.println(result);

        //将字符串补齐7位，空位用零补齐
        for(int i=0;i<7-count;i++){
            result="零"+result;
        }
        //System.out.println(result);

        //加上单位
        String ans="";
        for(int i=0;i<7;i++){
            ans=ans+result.charAt(i)+str2[i];
        }
        System.out.println(ans);
    }
}

练习5：手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

str.substring(1,5); //返回值是一个子串，原字符串无修改

//截取下标为1-4的子串——包头不包尾，包左不包右

str.substring(5); //截取下标为5到结尾的子串

package Code;

import java.util.Scanner;

public class test29 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入您的手机号：");
        String telNum= sc.next();
        System.out.println("您的手机号为：");
        System.out.println(telNum.substring(0,3)+"****"+telNum.substring(7));
    }
}

练习6：身份证信息查看

1-2 省份
3-4 城市
5-6 区县
7-14 出生年月日
15-16 所在地派出所
17 性别（奇数男偶数女）
18 个人信息码

package Code;

import java.util.Scanner;

public class tesr30 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入身份证号(17位)：");
        String str= sc.next();
        System.out.print("生日："+str.substring(6,10)+"年"+str.substring(10,12)+"月"+str.substring(12,14)+"日");
        System.out.println();
        //ASCII码表里 0 —— 48
        //System.out.println(str.charAt(16)-48);  //2
        if((str.charAt(16)-48)%2==0){
            System.out.println("性别：女");
        }else{
            System.out.println("性别：男");
        }
    }
}

练习7：敏感词替换

package Code;

public class test30 {
    public static void main(String[] args) {
        String str="cjm是大傻逼,cjm是大sb";
        System.out.println(str);
        String[] arr={"大傻逼","大SB","大sb"};  //敏感词库
        for (int i = 0; i < arr.length; i++) {
            str=str.replace(arr[i],"***");  //循环替换
        }
        System.out.println(str);  //cjm是***,cjm是***
    }
}

8.2.4 StringBuilder

StringBuilder可以看成是一个容器，创建之后的里面的内容可以改变

构造方法

StringBuilder sb=new StringBuilder();  //空参构造，创建一个空容器
StringBuilder sb=new StringBuilder("cjm是大傻逼");  //有参构造

常用方法

• append，添加数据，并返回对象本身
• reverse，反转容器里面的内容
• length，返回长度，即字符个数
• toString，将StringBuilder对象转换成字符串String

StringBuilder使用场景

• 字符串拼接
• 字符串反转

package Code;

public class test31 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb);
        //StringBuilder是Java已经写好的类，
        //Java在底层对它进行了一些特殊处理，打印对象不是地址值而是属性值（容器内容）
        
        sb.append("cjm").append("是").append("大傻逼");  
        //链式编程：不用变量接收返回值，继续调用其他方法
        System.out.println(sb);
    }
}

练习1：对称字符串

键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是

package Code;

import java.util.Scanner;

public class test32 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str= sc.next();

        //StringBuilder sb=new StringBuilder(str);
        //sb.reverse();
        //String newStr=sb.toString();
        
        String newStr=new StringBuilder().append(str).reverse().toString();  //链式编程
        if(newStr.equals(str)){
            System.out.println("yes");
        }else{
            System.out.println("no");
        }
    }
}

练习2：拼接字符串

需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。

​ 调用该方法，并在控制台输出结果。

​ 例如：数组为int[] arr = {1,2,3};

​ 执行方法后的输出结果为：[1, 2, 3]

package Code;

public class test33 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        System.out.println(connect(arr));

    }
    public static String connect(int[] arr){
        StringBuilder sb=new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                //sb.append(arr[i]+"]");
                //String concatenation as argument to 'StringBuilder.append()' call
                //StringBuffer对象的append方法目的就是做对象拼接用的,里面再通过"+"来拼接就不得当,这是编译器对Java的代码规范。
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        return sb.toString();
    }
}

8.2.5 StringJoiner

!!!JDK8出现的

构造方法

StringJoiner sj=new StringJoiner(",");  //连接符号
StringJoiner sj=new StringJoiner(",","[","]");  //连接符号，开始符号，结束符号

常用方法

• add，添加数据，并返回对象本身
• length，返回长度，即字符个数
• toString，将StringJoiner对象转换成字符串String

package Code;

import java.util.StringJoiner;

public class test34 {
    public static void main(String[] args) {
        StringJoiner sj=new StringJoiner(",","[","]");
        System.out.println(sj.length());  //2
        sj.add("aaa").add("bbb").add("ccc");
        System.out.println(sj.toString());  //[aaa,bbb,ccc]
    }
}

8.3 字符串原理

8.3.1 字符串存储的内存原理

• 直接赋值会复用字符串常量池中的
• new出来的不会复用，会重新开辟一个空间

8.3.2 ==比较的实质

• 基本数据类型比较的是数据值
• 引用数据类型比较的是地址值

8.3.3 字符串拼接的底层原理

1.拼接的过程没有变量参与

2.拼接的过程有变量参与

• JDK8以前：用StringBuilder

• JDK8:用数组

  系统会预估字符串拼接后的总大小，再把要拼接的内容放进数组中，最终生成字符串（不方便）

总结：

字符串拼接的时候有变量参与会导致在内存中创建很多对象，浪费空间，时间效率不高。

如果有很多字符串变量进行拼接，不要使用 “+” 拼接字符串。

8.3.4 StringBuilder提高效率内存图解

package Code;

public class test35 {
    public static void main(String[] args) {
        String str1="abc";
        String str2="a"+"b"+"c";  编译的时候将"a"+"b"+"c"拼接成"abc",会复用串池里面的字符串
        System.out.println(str1==str2);  //true
    }
}

8.3.5 StringBuilder源码分析

直接一次性添加数据：

• 默认创建一个容量为16的字节数组
• 添加的内容长度小于小于16，直接存
• 添加的内容长度大于16，扩容为34，容量变为：原始容量*2+2
• 添加的内容长度大于34，容量为实际长度

package Code;

public class test35 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb.capacity());  //容量16
        System.out.println(sb.length());  //长度0
        sb.append("abc");
        System.out.println(sb.capacity());  //16
        System.out.println(sb.length());  //3
    }
}

package Code;

public class test35 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb.capacity());  //容量16
        System.out.println(sb.length());  //长度0
        sb.append("abcdefghijklmnopqrstovwxyz");
        System.out.println(sb.capacity());  //34
       	System.out.println(sb.length());  //26
    }
}

package Code;

public class test35 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb.capacity());  //容量16
        System.out.println(sb.length());  //长度0
        sb.append("abcdefghijklmnopqrstovwxyz0123456789");
        System.out.println(sb.capacity());  //36
        System.out.println(sb.length());  //36
    }
}

package Code;

public class test35 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        System.out.println(sb.capacity());  //16
        System.out.println(sb.length());  //0
        
        sb.append("abc");
        System.out.println(sb.capacity());  //16
        System.out.println(sb.length());  //3
        
        sb.append("abcdefghijklmnopqrstovwxyz");
        System.out.println(sb.capacity());  //34=16*2+2
        System.out.println(sb.length());  //29
        
        sb.append("abcdefghijklmnopqrstovwxyz0123456789");
        System.out.println(sb.capacity());  //70=34*2+2
        System.out.println(sb.length());  //65
        
        sb.append("0123456789");
        System.out.println(sb.capacity());  //142=70*2+2
        System.out.println(sb.length());  //75
    }
}

8.4 综合练习

练习1：转换罗马数字

package Code;

import java.util.Scanner;

public class test37 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str;
        while (true){
            System.out.println("请输入数字：");
            str=sc.next();
            if(checkStr(str)){
                break;
            }else{
                System.out.println("数字不合法，请重新输入！");
                continue;
            }
        }
        System.out.println(connectStr(str));
    }

    public static boolean checkStr(String str) {
        if (str.length() > 9) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c < '0' || c > '9'){
                return false;
            }
        }
        return true;
    }

    public static String changeStr(int num) {
        String[] strArr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
        return strArr[num];
    }

    public static String connectStr(String str){
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            sb.append(changeStr(str.charAt(i)-48));
        }
        return sb.toString();
    }
}

package Code;

import com.sun.org.apache.bcel.internal.generic.SWITCH;

import java.util.Scanner;

public class test38 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str;
        while (true){
            System.out.println("请输入数字：");
            str=sc.next();
            if(checkStr(str)){
                break;
            }else{
                System.out.println("数字不合法，请重新输入！");
                continue;
            }
        }
        System.out.println(connectStr(str));
    }

    public static boolean checkStr(String str) {
        if (str.length() > 9) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c < '0' || c > '9'){
                return false;
            }
        }
        return true;
    }

    public static String changeStr(char c) {
       String str;
       switch(c){
           case'0':
               str="";
               break;
           case'1':
               str="Ⅰ";
               break;
           case'2':
               str="Ⅱ";
               break;
           case'3':
               str="Ⅲ";
               break;
           case'4':
               str="Ⅳ";
               break;
           case'5':
               str="Ⅴ";
               break;
           case'6':
               str="Ⅵ";
               break;
           case'7':
               str="Ⅶ";
               break;
           case'8':
               str="Ⅷ";
               break;
           case'9':
               str="Ⅸ";
               break;
           default:
               str="";
               break;
       }
       return str;
    }

    public static String connectStr(String str){
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            sb.append(changeStr(str.charAt(i)));
        }
        return sb.toString();
    }
}

练习2：调整字符串

package Code;

public class test39 {
    public static void main(String[] args) {
        String str1="abcdefgty";
        String str2="defgabcjk";
        System.out.println(compare(str1,str2));
    }
    
    public static boolean compare(String str1,String str2){
        int str1Len= str1.length();
        int str2Len=str2.length();
        if(str2Len!=str1Len){
            return false;
        }else{
            int count=str1.length();
            int i=0;
            while(i<count){
                if(str1.equals(str2)){
                    return true;
                }
                str1= str1.substring(1)+str1.charAt(0);
                i++;
            }
            return false;
        }
    }
}

练习3：打乱字符串

package Code;

import java.util.Random;
import java.util.Scanner;

public class test40 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个字符串:");
        String str=sc.next();  //输入一个字符串
        char[] ch=str.toCharArray();  //将字符串转换成字符数组
        Random r=new Random();
        for(int i=str.length()-1;i>0;i--){
            int loc=r.nextInt(i);
            char temp=ch[i];
            ch[i]=ch[loc];
            ch[loc]=temp;
        }
        String result=new String(ch);
        System.out.println(result);
    }
}

练习4：生成验证码

要求：长度为5，四个字母（不限大小写），一个数字

package Code;

import java.util.Random;

public class test41 {
    public static void main(String[] args) {
        String fourChar=getChar();  //随机获得四个字母
        String str=spliced(fourChar);  //四个字母与一个数字拼接
        String result=disrupt(str);  //打乱
        System.out.println(result);
    }

    //随机获得四个字母
    public static String getChar(){
        String[] str={"A","B","C","D","E","F","G", "H","I","J","K","L","M","N", "O","P","Q","R","S","T", "U","V",
                "W","X","Y","Z", "a","b","c","d","e","f", "g","h","i","j","k","l","m","n", "o","p","q","r","s","t","u","v","w","x","y","z"};
        int[] flag=new int[52];  //标记数组，初始化为0
        Random r=new Random();
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<4;i++){
            int loc=r.nextInt(52);
            if(flag[loc]==0){  //如果该字母未被使用
                sb.append(str[loc]);
                flag[loc]=1;  //标记为已使用
            }
        }
        return sb.toString();
    }

    //四个字母与一个数字拼接
    public static String spliced(String str){
        String[] strNum={"0","1","2","3","4","5","6","7","8","9"};
        Random r=new Random();
        int loc=r.nextInt(10);
        str=str+strNum[loc];
        return str;
    }

    //打乱验证码
    public static String disrupt(String str){
        char[] ch=str.toCharArray();
        Random r=new Random();
        for(int i=4;i>0;i--){
            int loc=r.nextInt(i);
            char temp=ch[i];
            ch[i]=ch[loc];
            ch[loc]=temp;
        }
        return new String(ch);
    }
}

练习5：给定两个字符串形式的非负整数，返回它们的乘积，乘积也是字符串形式

package Code;

public class test42 {
    public static void main(String[] args) {
        String str1="1234";
        String str2="4567";
        int num1=Integer.parseInt(str1);
        int num2=Integer.parseInt(str2);
        int num=num1*num2;
        //String result=""+num;
        //无法使用强制转换(String)num
        String result=String.valueOf(num);
        System.out.println(result);
    }
}

练习6：给定一个字符串，由若干单词组成，单词前后用一些空格隔开，求最后一个单词的长度

package Code;

public class test43 {
    public static void main(String[] args) {
        String str="Miracles happen every day   ";
        int count=0;
        int flag=0;
        for(int i=str.length()-1;i>0;i--){
            if(flag==1&&str.charAt(i)==' '){
                break;
            }
            if(str.charAt(i)!=' '){
                count++;
                flag=1;
            }
        }
        System.out.println("最后一个单词的长度为："+count);  //3
    }
}

!!!注意：不能用str.charAt(i)=='\u0000’判断是否为空格

运行结果如下：

package Code;

public class test43 {
    public static void main(String[] args) {
        String str="Miracles happen every day   ";
        int count=0;
        int flag=0;
        for(int i=str.length()-1;i>0;i--){
            if(flag==1&&str.charAt(i)=='\u0000'){
                break;
            }
            if(str.charAt(i)!='\u0000'){
                count++;
                flag=1;
            }
        }
        System.out.println("最后一个单词的长度为："+count);  //27
    }
}

9.1 ArrayList

集合长度可变，可存放引用数据类型，存放基本数据要将基本数据变成其对应的包装类

9.1.1 构造方法

package Code;

import java.util.ArrayList;

public class test44 {
    public static void main(String[] args) {
        //创建集合对象
        //泛型：限制集合存储的数据类型
        //JDK8以前：
        ArrayList<String> list1=new ArrayList<String>();
        //JDK7以后：
        ArrayList<String> list2=new ArrayList<>();
        //ArrayList是Java中已经写好的一个类，创建的list1、list2是对象，
        // Java在底层做了处理，打印对象显示的不是地址值，而是集合中存储的数据内容
        System.out.println(list1);  //[]
        System.out.println(list2);  //[]
    }
}

9.1.2 成员方法

package Code;

import java.util.ArrayList;

public class test45 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();

        //添加元素
        list.add("aaa");  //添加成功后返回true
        list.add("bbb");
        list.add("ccc");

        //删除元素
        list.remove("aaa");  //true
        list.remove("ddd");  //false
        list.remove(0);  //返回被删除的元素
        
        //得到特定元素
        String str=list.get(0);  //返回指定索引处的元素
        
        //得到集合的长度
        int len= list.size();
    }
}

9.3 基本数据类型对应的包装类

基本数据类型	对应的包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

package Code;

import java.util.ArrayList;

public class test45 {
    public static void main(String[] args) {
        ArrayList<Integer> list1=new ArrayList<>();
        //JDk5以后：int Integer类型可以互相转化
        list1.add(1);
        list1.add(2);
        list1.add(3);
        System.out.println(list1);  //[1, 2, 3]
        
        ArrayList<Character> list2=new ArrayList<>();
        list2.add('a');
        list2.add('b');
        list2.add('c');
        System.out.println(list2);  //[a, b, c]
    }
}

9.4 练习

练习1：添加学生信息1

package Code;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package Code;

import java.util.ArrayList;

public class test46 {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        
        Student s1=new Student("cjm",22);  //s1、s2为地址值
        Student s2=new Student("sqd",19);
        
        list.add(s1);
        list.add(s2);
        
        System.out.println(list);  //[Code.Student@1b6d3586, Code.Student@4554617c]
        
        for(int i=0;i<list.size();i++){
            Student stu=list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());
        }
        
    }
}

练习2：添加学生信息2

package Code;

import java.util.ArrayList;
import java.util.Scanner;

public class test47 {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        //System.out.println(list.size());  //0

        //键盘录入两个学生信息
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<2;i++){
            Student s=new Student();

            System.out.println("请输入姓名：");
            String name=sc.next();
            System.out.println("请输入年龄：");
            int age=sc.nextInt();

            s.setName(name);
            s.setAge(age);

            list.add(s);
        }

        //打印学生信息
        for(Student i:list){  //增强 for 循环
            System.out.println(i.getName()+","+i.getAge());
        }

    }
}

练习3：添加用户对象，根据ID查找用户信息

package Code;

public class User {
    private String ID;
    private String userName;
    private String passWord;

    public User() {
    }

    public User(String ID, String userName, String passWord) {
        this.ID = ID;
        this.userName = userName;
        this.passWord = passWord;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

package Code;

import java.util.ArrayList;
import java.util.Scanner;

public class test48 {
    public static void main(String[] args) {
        //创建用户信息库
        ArrayList<User> list=new ArrayList<>();
        User u1=new User("01","cjm","1234");
        User u2=new User("02","sqd","1234");
        list.add(u1);
        list.add(u2);

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要查询的用户ID：");
        String ID=sc.next();
        check(ID,list);
    }


    //根据id查找用户信息
    public static void check(String ID,ArrayList<User> list){
        int flag=0;
        for(User i:list){
            if(i.getID().equals(ID)){
                flag=1;
                System.out.println("该用户存在！用户信息如下：");
                System.out.println("ID:"+i.getID());
                System.out.println("用户名："+i.getUserName());
                System.out.println("密码："+i.getPassWord());
            }
        }
        if(flag==0){
            System.out.println("该用户不存在！");
        }
    }
}

练习4：添加用户对象并判断是否已经存在，并返回索引

package Code;

import java.util.ArrayList;
import java.util.Scanner;

public class test49 {
    public static void main(String[] args) {
        //创建用户信息库
        ArrayList<User> list=new ArrayList<>();
        User u1=new User("01","cjm","1234");
        User u2=new User("02","sqd","1234");
        list.add(u1);
        list.add(u2);

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要查询的用户ID：");
        String ID=sc.next();
        System.out.println(getIndex(ID,list));
        System.out.println(isExit(ID,list));
    }

    public static boolean isExit(String ID,ArrayList<User> list){
        return getIndex(ID,list)>=0;
    }

    public static int getIndex(String ID,ArrayList<User> list){
        for(int i=0;i<list.size();i++){
            if(list.get(i).getID().equals(ID)){
                return i;
            }
        }
        return -1;
    }
}

练习5 返回特定元素集合

package Code;

public class Phone {
    private String brand;
    private int price;

    public Phone() {
    }

    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

package Code;

import java.util.ArrayList;

public class test50 {
    public static void main(String[] args) {
        ArrayList<Phone> list=new ArrayList<>();
        Phone p1=new Phone("小米",2999);
        Phone p2=new Phone("红米",2299);
        Phone p3=new Phone("苹果",5999);
        list.add(p1);
        list.add(p2);
        list.add(p3);
        
        ArrayList<Phone> resultList=phone(list);
        
        for(Phone i:resultList){
            System.out.println("手机品牌："+i.getBrand());
            System.out.println("价格："+i.getPrice());
            System.out.println();
        }
    }
    
    //将价格低于3000的手机集合返回
    public static ArrayList<Phone> phone(ArrayList<Phone> list){
        ArrayList<Phone> resultList=new ArrayList<>();
        for(Phone i:list){
            if(i.getPrice()<3000){
                resultList.add(i);
            }
        }
        return resultList;
    }
}