一.基础篇：基础语法-编程知识

1. 注释

2. 字面量

3. 变量

4. 基本数据类型

5. 键盘录入

6.运算符

6.1 算符运算符

6.2 算术运算符-隐式转换

6.3 算数运算符-强制转换

6.4 自增和自减运算符

6.5 四逻辑运算符

6.6 短路逻辑运算符

6.7 三元运算符

6.8 运算符优先级

7. 流程控制语句

7.1 顺序结构

7.2 分支结构

if 分支方式一

if 分支方式二

if 分支方式三

switch 分支

7.3 循环结构

for 循环

while 循环

do...while 循环

8. 数组

8.1 什么是数组

8.2 数组的定义和使用

1. 数组的静态初始化

2. 数组的地址值

3. 数组的元素访问

4. 数组的遍历

5. 数组动态初始化

6. 数组动态初始化和数组静态初始化的区别

7. 数组常见问题

9. 方法

9.1 什么是方法

9.2 方法的格式

1. 最简单的方法定义

2. 带参数的方法定义

3. 带返回值方法的定义

方法的注意事项

9.3 方法重载

10. 面向对象-基础

10.1 类和对象

10.2 封装

10.3 private关键字

10.4 this关键字

10.5 构造方法

10.6 标准的javabean类

10.7 基本数据类型和引用数据类型

11. 字符串

11.1 字符串String概述：

11.2 创建String对象的两种方式：

11.3 字符串比较 ==

11.4 字符串比较 equals和equalslgnoreCase

11.5 登录

11.6 遍历字符串

11.7 StringBuilder 基本操作

11.8 StringJoiner 基本操作

12. 集合-基础

12.1 什么是集合

12.2 ArrayList 基本使用

1. 注释

什么是注释：
- 注释就是对代码进行解释说明的文字
注释分类：
- 单行注释：// 注释信息
- 多行注释：/*注释信息*/
- 文档注释：/**注释信息*/
注释的使用细节：
- 注释内容不会参与编译和运行，仅仅是对代码的解释说明
- 不管是当行注释还是多行注释，都不要去嵌套使用

代码示例：

package code1;public class Zhushi {public static void main(String[] args) {// 单行注释/** 多行注释* */}
}/** * 文档注释** @author 小明* @version 1.1* */
class ZhushiCode{public static int getMax(){return 1;}
}

2. 字面量

什么是字面量？
- 字面量就是告诉，程序员数据在程序中的书写格式
字面量的类型：

代码示例：

package code1;public class Zimianl {public static void main(String[] args) {// 以下是常见的数据类型在代码中是如何书写的System.out.println(100);System.out.println(1.123);System.out.println("hello");System.out.println('男');System.out.println(true);// null不能直接打印,如果要打印null,只能用字符串打印System.out.println("null");}
}

3. 变量

什么是变量？
- 变量就是在执行过程中，值有可能发生改变的数据
变量的定义格式：数据类型变量名 = 数据值;

代码示例：

package code1;public class Bianliang {public static void main(String[] args) {// 变量的定义String name = "xiaoming";System.out.println(name);}
}

4. 基本数据类型

整数默认为int类型，浮点数默认为double类型

代码示例：

package code1;public class ShujuLeiXIng {public static void main(String[] args) {// bytebyte b1 = 127;byte b2 = -128;// shortshort s1 = 32767;short s2 = -32768;// intint i1 = 2147483647;int i2 = -2147483648;// long// 注意点: 如果要定义long类型的变量,要在数据值的后面加一个Llong l1 = 9223372036854775807L;long l2 = -9223372036854775808L;// float// 注意点: 如果要定义float类型的变量,要在数据值的后面加一个Ffloat f1 = 3.402823e+38F;float f2 = -3.401298e038F;// doubledouble d1 = 1.79769e+308;double d2 = -4.900000000;// charchar c1 = 0;char c3 = '中';// booleanboolean b11 = true;boolean b22 = false;}
}

小结：

Java语言的数据类型分为：基本数据类型，引用数据类型
基本数据类型的四类八种：
取值范围大小关系：从double到byte，doube是最大的
注意点：

5. 键盘录入

键盘录入：java中提供了一个类叫 Scanner，这个类可以接收键盘输入的数字
使用Scanner步骤：
1. 导入Scanner类，简称导包: import java.util.Scanner;
2. 创建对象: Scanner sc = new Scanner(System.in);
3. 使用Scanner接收数据: int i = sc.nextInt();

示例代码：


package code1;
// 1. 导包,导入Scanner类
import java.util.Scanner;public class JianPanLuru {public static void main(String[] args) {//2. 创建对象Scanner sc = new Scanner(System.in);System.out.println("请输入整数: ");//3. 接收数据// 变量 i 记录键盘录入的数据int i = sc.nextInt();System.out.println("你输入了:" + i);}
}

6.运算符

6.1 算符运算符

示例代码：

package code2;public class SuanshuYUnsua {public static void main(String[] args) {// +System.out.println(1 + 2);// -System.out.println(33 - 11);// *System.out.println(11 * 100);// /System.out.println(10 / 2);// %System.out.println(10 % 12);}
}

6.2 算术运算符-隐式转换

隐式转换的两种提升规则：

1. 取值范围小的，和取值返回大的进行运算，小的会先提升为大的，在进行运算

public class Test{

public static viod main(String[] args){

int a = 10;

double b = 12.3;

// 这里的double比int大，所以会提升为double在进行计算，所以类型也是double

double c = a + b;

}

}

2. byte,short,char 三种类型的数据在算数运算的时候，都会直接先提升为int，然后在进行计算

public class Test{

public static viod main(String[] args){

byte a = 10;

byte b = 20;

// 可以看到以下的图中大小int在float和byte前面，所以int

int c = a + b;

}

}

隐式转换小结：

6.3 算数运算符-强制转换

示例代码：

package code2;public class SuanShuYunSuanFuQzzh {public static void main(String[] args) {// 将double的值复制给int// double取值范围比int大,这时候就需要使用到强制转换double a = 10;int b = (int ) a;System.out.println(b);}
}

6.4 自增和自减运算符

示例代码：

package code2;public class ZzZj {public static void main(String[] args) {int a = 1;// 把变量a的值加 1++a;System.out.println(a);// 2// 把变量a的值减 1--a;System.out.println(a);// 1}
}

6.5 四逻辑运算符

6.6 短路逻辑运算符

短路运算符的短路效果：左边的表达式能确定最终的结果，右边就不会参与运算了

示例代码：

package code2;public class Dlysf {public static void main(String[] args) {System.out.println(true && true);System.out.println(false && false);System.out.println(true && false);System.out.println(false && true);System.out.println(true || true);System.out.println(true || false);System.out.println(false || true);System.out.println(false || false);}
}

6.7 三元运算符

示例代码：

package code2;public class Sybds {public static void main(String[] args) {int max = 20 > 10 ? 100 : 200;System.out.println(max);}
}

6.8 运算符优先级

其实以上的运算符挺多的，但是只要记住一点就行了，括号 () 优先于所有运算符

示例代码：

package code2;public class Yxj {public static void main(String[] args) {// 括号中的 200 * 200 先计算,因为()中的内容优先级所有的运算符System.out.println(1 * 100 + (200 * 200));}
}

7. 流程控制语句

流程控制语句分为三种：

顺序结构
分支结构
循环结构

7.1 顺序结构

顺序结构是java程序默认的执行流程，按照代码的先后顺序，从上到下依次执行

示例代码：

package code3;public class LiucKongZhiYuju {public static void main(String[] args) {System.out.println(1);System.out.println(2);System.out.println(3);System.out.println(4);System.out.println(5);}
}

7.2 分支结构

分支结构分为两种：

if分支
switch分支

if 分支方式一

示例代码：

public class Test {public static void main(String args[]){int x = 10;if( x < 20 ){System.out.print("这是 if 语句");}}
}

if 分支方式二

示例代码：

public class Test {public static void main(String args[]){int x = 10;if( x < 20 ){System.out.print("这是 if 语句");}else{System.out.print("这是 else 语句");}}
}

if 分支方式三

示例代码：

public class Test {public static void main(String args[]){int x = 10;if( x < 20 ){System.out.print("这是 if 语句");}else if(x > 5){System.out.print("这是 else if 语句");}else{System.out.print("这是 else 语句");}}
}

switch 分支

示例代码：

package code3;public class LiucKongZhiYuju {public static void main(String[] args) {switch (10){case 10:System.out.println(10);break;case 20:System.out.println(20);break; default:System.out.println("default");}}
}

7.3 循环结构

循环的分类：

for
while
do....while

for 循环

while 循环

do...while 循环

8. 数组

8.1 什么是数组

int类型的数组容器可以存储，byte，short，int

int类型的数组容器可以存储byte、short和int类型的数据是因为byte和short类型的数值可以通过自动类型转换被转换为int类型的数值
在Java中，byte类型存储的是8位有符号整数，而short类型存储的是16位有符号整数。由于int类型存储的是32位有符号整数，所以byte和short类型的数值可以容纳在int类型的范围内
当我们将byte或short类型的数值存储到int类型的数组中时，编译器会自动进行类型转换，将byte或short类型的数据扩展为32位的int类型数据，并存储到数组中

double类型的数组容器可以存储，byte，short，int，long，float，double

byte、short、int、long、float这些数据类型的范围都比double要小。当将它们赋值给double数组时，会进行隐式转换，将其转换为double类型并存储在数组中

8.2 数组的定义和使用

数组的定义：

方式一：
方式二：

1. 数组的静态初始化

初始化：就是在内存中，为数组容器开辟空间，并将数据存入到容器中的过程
完整格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素N};
整数数组-示例代码：int[] array = new int[]{1,2,3,4,5};
小数数组-示例代码：double[] array2 = new double[]{11.1,22.2,33.4};

示例代码：

package code3;public class Shuzu {public static void main(String[] args) {/** 静态初始化语法格式：*   数据类型[] 数组名 = new 数据类型[]{初始化的数据};* 静态初始化简化语法:*   数据类型[] 数组名 = {初始化数据};* */// 需求1：定义数组存储5个学生的年龄int[] xq1 = new int[]{1,23,4,5}; // 标准语法int[] xq2 = {1,23,4,5}; // 简化语法// 需求2：定义数组存储3个学生的姓名String[] xq3 = new String[]{"小红","小明"};String[] xq4 = {"小明","小兰"};// 需求3：定义数组存储4个学生的身高double[] xq5 = new double[]{1.12,1.23};double[] xq6 = {1.111,23.33};}
}

2. 数组的地址值

当我们定义好数组后，输出的是一个数组的地址值，数组的地址值表示数组在内存中的位置

数组在内存中中会开启一个数组，数组中存储的就是数组中的数据

数组地址值的格式含义：[I@4eec7777

[ 表示当前是一个数组
I 表示当前数组里面的元素都是int类型
@ 表示一个建个符号，(固定的)
4eec7777 是数组正在的地址值(十六进制)

3. 数组的元素访问

数组元素的访问语法格式：数组名[索引]

示例代码：

package code3;public class Shuzu {public static void main(String[] args) {// 利用索引对数组中的元素进行访问// 1. 获取数组里面的元素// 格式: 数组名[索引]int[] xq5 = new int[]{1,2,3,4,5};System.out.println(xq5[0]); // 1// 2.把数据存储到数组中// 格式: 数组名[索引] = 具体数据或有值的变量// 细节: 添加数据后,数组中存在对应索引位置的数据将被覆盖xq5[1] = 100;System.out.println(xq5[1]); // 100}
}

4. 数组的遍历

数组的遍历：就是将数组中所有的内容取出来，取出来之后可以(打印，求和，判断等)
注意：遍历指的是取出数组中数据的过程，不要局限的理解为，遍历就是打印。

示例代码：

package code3;public class Shuzu {public static void main(String[] args) {//1.定义数组int[] xq5 = new int[]{1,2,3,4,5};//2.遍历数组// 方式一for (int i : xq5) {System.out.println(i);}// 方式二System.out.println("----------------");for (int i = 0; i < xq5.length; i++) {System.out.println(xq5[i]);}}
}

5. 数组动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度]
示例：int[] arr = new int[3]
- 以上的3表示数组的长度为3

示例代码：

package code3;public class Shuzu {public static void main(String[] args) {// 数组动态初始化语法格式:// 数据类型[] 数组名 = new 数据类型[数组的长度];// 在创建时，由我们指定数组的长度,由虚拟机给出默认的初始化值String[] arr = new String[50];arr[0] = "小红";System.out.println(arr[0]); // 小红}
}

6. 数组动态初始化和数组静态初始化的区别

动态初始化：手动指定数组的长度，由系统给出默认初始化值
静态初始化：手动指定数组元素，系统会根据元素的个数，计算出数组的长度

7. 数组常见问题

当访问了数组中不存在的索引，就会引发索引越界异常

9. 方法

9.1 什么是方法

什么是方法？
1. 方法就是程序中最小的执行单元
实际开发中，什么时候用到方法？、
1. 重复的代码，具有独立功能的代码，可以抽取到方法中
实际开发中，方法有什么好处？
1. 可以提高代码的复用性
2. 可以提高代码的可维护性

方法定义：

把一些代码打包在一起，该过程称为方法定义

方法调用：

方法定义后并不是直接运行的，需要手动调用才能执行，该过程称为方法调用

9.2 方法的格式

1. 最简单的方法定义

示例代码：

public class Test {public static void main(String[] args) {// 调用方法playGame();}// 最简单的方法定义public static void playGame(){for (int i = 0; i < 10; i++) {System.out.println("hello world 你好啊 小" + i);}}
}

2. 带参数的方法定义

示例代码：

public class Test {public static void main(String[] args) {// 调用方法playGame(10,20);}// 带参数的方法定义public static void playGame(int a, int b){System.out.println(a + b);}
}

3. 带返回值方法的定义

示例代码：

public class Test {public static void main(String[] args) {// 调用方法int i = playGame(10, 20);System.out.println(i);}// 带参数的方法定义public static int playGame(int a, int b){return a + b;}
}

方法的注意事项

9.3 方法重载

总的来说，构成重载的是前提是，方法名要相同，参数要不同的方法才构成重载

示例代码：

public class Test {public static void main(String[] args) {sayHello("小红");sayHello("小明",10);sayHello("小白","男");}public static void sayHello(String name){System.out.println("姓名: " + name);}public static void sayHello(String name,int age){System.out.println("姓名: " + name + "年龄: " + age);}public static void sayHello(String name, String sex){System.out.println("姓名: " + name + "性别: " + sex);}}

10. 面向对象-基础

10.1 类和对象

如何定义类：

示例代码：

PhoneTest.java


public class PhoneTest {public static void main(String[] args) {Phone phone = new Phone();// 给手机属性赋值phone.brand = "小米";phone.price = 1999.9;// 调用手机方法phone.call();}
}

Phone.java

// 定义一个手机类
public class Phone {// 属性String brand;double price;// 方法:public void call(){System.out.println("手机在打电话");}public void playGame(){System.out.println("手机在玩游戏");}
}

小结：

定义类的注意事项：

用来描述一类事物中的类，叫做：javabean类，在javabean类中，是不写main方法的
编写main方法的类，叫测试类，可以在测试类中创建javabean类的对象进行赋值调用

10.2 封装

在Java中，封装是一种将相关的数据和方法集中在一个类中的机制。封装可以隐藏对象的具体实现细节，只暴露一些必要的接口供其他对象使用。这样可以提高代码的可维护性和安全性。

封装可以通过以下方式实现：

1. 使用访问修饰符(private、protected、public)将类的字段和方法的访问权限限制在类的内部或特定范围内。
2. 使用getters和setters方法来控制对类的字段的访问，从而实现对字段的封装。
3. 使用构造函数来初始化对象的字段，并将字段声明为私有，以限制对字段的访问。
4. 使用关键字final来限制类、字段或方法的修改和继承，从而保护封装性。
5. 使用包(package)将类组织在一起，实现对类的封装，避免类的冲突和重复。

封装示例代码：定义一个人的类，人有姓名，年龄属性，吃饭。睡觉方法

public class Ren {String name;int age;public static void cf(){System.out.println("吃饭");}public static void shuij(){System.out.println("睡觉");}
}

10.3 private关键字

private是一个权限修饰符
可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问

示例代码：使用 private修饰符修饰成员变量 age

public class GirLFriend {private int age;// set赋值public void setAge(int a) {if (a >= 18 && a <= 50){age = a;}else{System.out.println("非法数据");}}// 获取数据public int getAge() {return age;}
}

小结：

10.4 this关键字

this的作用，可以区别成员变量和局部变量

当在一个类中，定义了成员变量名为age时，而又在method方法中定义了一个age变量，这时候如果使用print输出，那么java会根据就近原则优先使用method中的age变量，而不是成员变量age。这时候可以使用this关键字，来指明要使用的是成员变量age。例如：this.age

public class GirLFriend {private int age;// set赋值public void setAge(int age) {if (age >= 18 && age <= 50){this.age = age;}else{System.out.println("非法数据");}}// 获取数据public int getAge() {return age;}
}

10.5 构造方法

构造方法也可以称为构造函数。
作用：在创建对象的时候给成员变量进行初始化
特点：
- 方法名与类名相同，大小写也要一致
- 没有返回值类型，连void都没有
- 没有具体的返回值(不能由return待会结果数据)
构造方法的执行时机：
- 创建对象的时候由虚拟机调用，不能手动调用构造方法
- 每创建一次对象，就会调用一次构造方法
构造方法的定义有两种：
- 有参构造方法
- 无参构造方法

示例代码：

public class Test {public static void main(String[] args) {TestCode t = new TestCode();TestCode t1 = new TestCode("小红",10);}
}class TestCode{private String name;private int age;// 无参的构造方法public TestCode(){System.out.println("无参构造方法");}// 有参的构造方法public TestCode(String name,int age){// 做一些初始化操作,例如赋值给私有的成员变量this.name = name;this.age = age;}
}

构造方法注意事项：

小结：

10.6 标准的javabean类

定义标准的javabean类需要具备以下条件：

类名需要见名知易
成员变量使用private修饰
提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
成员的方法：
- 提供每一个成员变量对应的 setXxx()和setXxx() 方法
- 如果还有其他行为方法，也需要加上

示例代码：

public class Test {public static void main(String[] args) {User u = new User("xiaoming","12312da","123@qq.com","男",10);}
}class User{// 属性private String username;private String password;private String email;private String gender;private int age;// 空参构造方法public User() {}// 有参构造方法public User(String username, String password, String email, String gender, int age) {this.username = username;this.password = password;this.email = email;this.gender = gender;this.age = age;}/*** 获取* @return username*/public String getUsername() {return username;}/*** 设置* @param username*/public void setUsername(String username) {this.username = username;}/*** 获取* @return password*/public String getPassword() {return password;}/*** 设置* @param password*/public void setPassword(String password) {this.password = password;}/*** 获取* @return email*/public String getEmail() {return email;}/*** 设置* @param email*/public void setEmail(String email) {this.email = email;}/*** 获取* @return gender*/public String getGender() {return gender;}/*** 设置* @param gender*/public void setGender(String gender) {this.gender = gender;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}public String toString() {return "User{username = " + username + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";}
}

10.7 基本数据类型和引用数据类型

Java面向对象中的基本数据类型有：byte、short、int、long、float、double、boolean、char。

而引用数据类型包括：类、接口、数组。

基本数据类型的值直接存储在变量中，而引用数据类型的变量存储的是对象的引用，即对象存储在堆内存中，而栈内存中存储的是引用。

基本数据类型在赋值时，是将值直接复制给变量；而引用数据类型在赋值时，是将对象的引用复制给变量，这样多个变量可以指向同一个对象。

从内存的角度去解释：

11. 字符串

11.1 字符串String概述：

String是Java定义好的一个类。定义在java.lang包中，所以使用的时候不需要导包
java程序中的所有字符串文字(例如： "小明" )，都是String类的对象
字符串不可变，它们的值在创建后不能被更改

11.2 创建String对象的两种方式：

直接赋值的方式：String name = "小明";
构造方法的方式：有四种

示例代码：

import com.sun.security.jgss.GSSUtil;public class Test {public static void main(String[] args) {// 1.直接赋值的方式获取一个字符串对象String s1 = "小明";System.out.println(s1);// 2.通过new的方式创建字符串对象// 空参构造: 可以得到一个空白的字符串对象String s2 = new String();System.out.println(s2);// 传递一个字符串参数,根据传递的字符串内容创建一个新的字符串对象String s3 = new String("小红");System.out.println(s3);// 传递字符数组,根据字符数组的内容创建新的字符串对象char[] chs = {'a','b','c','d'};String s4 = new String(chs);System.out.println(s4);// 传递字节数组,根据字节数组的内容创建新的字符串对象// 应用场景: 在网络中传输的数据其实都是字节信息,一般要把得到的字节信息转成字符串,就要像以下方式进行构造byte[] bys = {97,98,99,100};String s5 = new String(bys);System.out.println(s5);}
}

11.3 字符串比较 ==

基本数据类型：比较的是数据值
引用数据类型：比较的是地址值
字符串比较-示例：

示例代码：

import com.sun.security.jgss.GSSUtil;public class Test {public static void main(String[] args) {// == 号比较// 使用 == 号比较基本数据类型: 比的是数据值// 使用 == 号比较引用数据类型: 比的是地址值// 基本数据类型: 比的是数据值String s1 = "abc";String s2 = "abc";System.out.println(s1 == s2); // true// 引用数据类型: 比的是地址值String s3 = new String("小红");String s4 = new String("小红");System.out.println(s3 == s4); // false}
}

11.4 字符串比较 equals和equalslgnoreCase

equals：比较字符串内容是否完全一样结果才是true，否则false
quealsIgnoreCase：比较字符串内容是否相等，忽略字符串大小写的比较

示例代码：

import com.sun.security.jgss.GSSUtil;public class Test {public static void main(String[] args) {// 比较s2的是是否和s1的值是一样的String s1 = "小红";String s2 = "小红";System.out.println(s1.equals(s2)); // true// 不区分大小写进行比较String s3 = "AbcDEFG";String s4 = "abcdefg";System.out.println(s3.equalsIgnoreCase(s4)); // true}
}

11.5 登录

需求：已知正确的用户名和密码，请用程序实现模拟用户登录，给3次机会，登录之后，给出相应的提示。

import com.sun.security.jgss.GSSUtil;import java.util.Scanner;public class Test {public static void main(String[] args) {// 已知账号密码String rightUsername = "admin";String rightPassword = "admin";// 键盘录入Scanner scanner = new Scanner(System.in);for (int i = 1; i < 4; i++) {System.out.println("请输入用户名: ");String username = scanner.next();System.out.println("请输入密码: ");String password = scanner.next();// 比较if (username.equals(rightUsername) && password.equals(rightPassword)){System.out.println("登录成功");break;}else{System.out.println("用户登录失败,用户名或密码错误,还剩下"+ i + "次机会");}}}
}

11.6 遍历字符串

使用charAt(int index)方法，根据索引返回字符
使用length()方法，获取字符串的长度

示例代码：

import com.sun.security.jgss.GSSUtil;import java.util.Scanner;public class Test {public static void main(String[] args) {// 键盘录入字符串,并进行遍历Scanner scanner = new Scanner(System.in);String input = scanner.next();System.out.println("请输入内容: ");for (int i = 0; i < input.length(); i++) {char c = input.charAt(i);System.out.println(c);}}
}

字符串常用方法：

1. length()：返回字符串的长度。
2. charAt(index)：返回字符串中指定索引位置的字符。
3. substring(startIndex, endIndex)：返回字符串中从startIndex位置到endIndex位置之间的子字符串。
4. indexOf(str)：返回字符串中第一次出现指定字符串str的索引位置。
5. lastIndexOf(str)：返回字符串中最后一次出现指定字符串str的索引位置。
6. equals(str)：比较字符串是否相等。
7. contains(str)：判断字符串是否包含指定字符串str。
8. startsWith(prefix)：判断字符串是否以指定的前缀prefix开头。
9. endsWith(suffix)：判断字符串是否以指定的后缀suffix结尾。
10. toUpperCase()：将字符串转换为大写。
11. toLowerCase()：将字符串转换为小写。
12. trim()：去除字符串首尾的空格。
13. replace(oldStr, newStr)：将字符串中的oldStr替换为newStr。
14. split(regex)：将字符串以指定的正则表达式regex分割为字符串数组。
15. concat(str)：将两个字符串连接起来。
16. compareTo(str)：按字典顺序比较两个字符串。
这些方法只是Java字符串类提供的一部分常用方法，还有许多其他方法可以用于处理和操作字符串。

11.7 StringBuilder 基本操作

概述：

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的，可以用去提高字符串的操作效率

StringBuilder构造方法：

StringBuidler() 创建一个空白可变字符串对象，不含有任何内容
StringBuilder(String str) 根据字符串的内容，创建可变字符串对象

StringBuilder常用方法：

append(任意类型) 添加数据，并返回对象本身
reverse() 反转容器中的内容

示例代码：

public class Test {public static void main(String[] args) {// StringBuilder// 1. 创建对象StringBuilder sb = new StringBuilder("hello world");// 打印StringBuilder时打印的是属性值,不是地址值System.out.println(sb); // hello world// 2. 添加元素sb.append(1);sb.append(1.2);sb.append(true);System.out.println(sb); // hello world11.2true// 3. 反转System.out.println(sb.reverse()); // eurt2.11dlrow olleh// 4. 获取长度System.out.println(sb.length()); // 19}
}

链式编程：

import java.util.Scanner;public class Test {public static void main(String[] args) {// 链式编程:// 在调用一个方法的时候,不需要用变量接收他的结果,可以继续调用其他方法int length = getString().substring(1).replace("A", "Q").length();System.out.println(length);}public static String getString(){Scanner scanner = new Scanner(System.in);System.out.println("请输入一个字符串: ");String str = scanner.next();return str;}
}

11.8 StringJoiner 基本操作

概述

StringJoiner跟StringBuidler一样，也可以看成一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率，而且代码编写特别简洁

构造方法：

StringJoiner(间隔符号) 创建StringJoiner对象，指定拼接时的间隔符号
StringJoiner(间隔符号，开始符号，结束符号) 创建一个StringJoiner对象，指定拼接时的间隔符号，开始符号，结束符号

成员方法：

add 添加数据，返回对象本身
length() 返回长度
toString() 返回一个字符串(拼接后的字符串)

示例代码：

import java.util.StringJoiner;public class Test {public static void main(String[] args) {//int[] arr = {1,2,3};StringJoiner sj = new StringJoiner(", ","[","]");for (int i = 0; i < arr.length; i++) {sj.add(arr[i] + "");}System.out.println(sj);}
}

import java.util.StringJoiner;public class Test {public static void main(String[] args) {// 创建一个对象,并指定中间的间隔StringJoiner sj = new StringJoiner("---");// 添加元素sj.add("1").add("2").add("3");System.out.println(sj);// 1---2---3}
}

12. 集合-基础

12.1 什么是集合

如果想同时存储多个元素，这时候用什么？

可以用数组，但是数组存在一些弊端，因为数组的长度是固定的
但是可以使用集合，集合和数组一样可以用来存储多个数据，但是集合的长度是可以发生变化的
在集合中，当添加一个元素的时候，集合的长度会自动+1。依次添加下去。总的来说集合会自动扩容

集合存储数据类型的特点：

集合：不能直接存储基本数据类型，可以存在引用类型，如果要存储基本数据类型需要包装类
数组：可以存储基本数据类型和引用数据类型：

集合和数组的对比：

集合的长度是可变的，可以存引用数据类型，如果要存储基本数据类型，需要讲基本数据类型转换为包装类
数组的长度是固定的，可以存储基本数据类型和引用数据类型

12.2 ArrayList 基本使用

ArrayList 动态数组，可以根据需要自动扩展容量

基本使用：

import java.util.ArrayList;public class Test {public static void main(String[] args) {// 创建集合对象// 泛型: 限定集合的存储数据类型// jdk7以前的写法// ArrayList<String> list = new ArrayList<String>();// jdk7以后的写法// 此时创建的ArrayList的对象,而ArrayList是java已经写好的类ArrayList<String> list = new ArrayList<>();System.out.println(list);}
}

ArrayList的成员方法：增删改查

增删改查示例代码：

import java.util.ArrayList;public class Test {public static void main(String[] args) {// 创建一个集合ArrayList<String> list = new ArrayList<>();// add 添加元素list.add("小明");list.add("aaaa");list.add("cccc");list.add("dddd");System.out.println(list);// remove 删除元素// 通过索引删除,会返回删除的元素
//        String remove = list.remove(0);
//        System.out.println(remove);
//        System.out.println(list);
//
//        // 通过数据值删除,会返回boolean
//        boolean aaaa = list.remove("aaaa");
//        System.out.println(aaaa);
//        System.out.println(list);// 修改元素// 修改元素,会将被修改的元素进行返回
//        String dwadawdawda = list.set(1, "dwadawdawda");
//        System.out.println(dwadawdawda);// 查询元素单个元素
//        String s = list.get(0);
//        System.out.println(s);// 获取集合的长度
//        int size = list.size();
//        System.out.println(size);// 遍历集合for (String s : list) {System.out.println(s);}}
}