JAVA 自学知识点必备（入门级）

java基础入门
能够说出Java语言的跨平台原理
通过在不同的操作系统上安装对应版本的Java虚拟机实现的
能够独立下载并安装JDK
能够独立配置path环境变量
能够独立编写HelloWorld案例并编译执行
能够说出Java中的8种基本数据类型
整数类型
byte, short, int, long
浮点类型
float, double
字符类型
char
布尔类型
boolean
能够定义基本数据类型的变量并使用变量名输出
数据类型 变量名 = 值;
能够说出标识符的命名规则
由字母、数字、下划线（_）、美元符号（$）组成
不能以数字开头
不能使用关键字
严格区分大小写
能够说出基本数据类型之间相互转换的规则
byte -> short -> int -> long -> float -> double
char ↗

java基础——运算符，if语句
*
能够说出常见的运算符有哪几种

+, -, *, /, %
*
能够知道除法和取余的区别

除法得到的是商
取余得到的是余数

	* 

整数相除只能得到整数，要想得到小数结果，必须要有浮点数参与运算
*
能够完成字符和字符串的加法
*
能够知道&&和&的区别

&& 短路与 ：如果左边为false，右边就不执行了
& 逻辑与 ：左边为false，右边还是要执行
*
能够使用三元运算符完成获取两个数中较大值

int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);
*
能够使用键盘录入数据并完成两个数据求和

	* 

导包

import java.util.Scanner;

	* 

创建Scanner对象

Scanner sc = new Scanner(System.in);

	* 

接收数据

sc.nextInt(), sc.nextDouble(), sc.nextFloat(), sc.nextBoolean(), sc.nextLine();
*
能够使用if语句完成获取两个数中较大值
*
能够使用if语句完成根据分数输出对应级别

java基础——switch结构，for循环，while循环，循环嵌套，随机数

switch 结构
语法格式
switch (表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
default:
语句体n+1;
[break;] //可以省略
}
执行流程
*
计算表达式的值
*
拿着表达式的值依次和 case 后面的值进行匹配
*
如果匹配上了，就执行对应的语句体
*
如果所有的 case 都匹配不上，就执行 default 中的语句体

注意事项
*
case 后面的值只能是常量，不能是变量
*
case 后面的值不允许重复定义

表达式能够接受的类型
*
byte, short, char, int （能够自动提升为 int 的类型）
*
枚举类型（JDK1.5）
*
字符串类型（JDK1.7）
*
if 和 switch 如何选择
*
如果需要进行范围判断，推荐使用 if
*
如果是固定选项的匹配，推荐使用 switch

for 循环
语法格式
for (初始化语句; 条件判断语句; 条件控制语句) {
循环体语句;
}
执行流程
1.
执行初始化语句
2.
执行条件判断语句

	* 

结果为 true，执行循环体语句
*
结果为 false，结束循环

1. 

执行条件控制语句
2.
回到第2步，继续执行条件判断语句

while 循环
语法格式
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
执行流程
1.
执行初始化语句
2.
执行条件判断语句

	* 

结果为 true，执行循环体语句
*
结果为 false，结束循环

1. 

执行条件控制语句
2.
回到第2步，继续执行条件判断语句

do while 循环（了解）
语法格式
初始化语句;
do {
循环体语句;
条件控制语句;
} while (条件判断语句);
执行流程
1.
执行初始化语句
2.
执行循环体语句
3.
执行条件控制语句
4.
执行条件判断语句

	* 

结果为 true，继续执行循环体语句
*
结果为 false，结束循环

特点
do while 循环，无论条件判断语句是否成立，都至少会执行一次循环体！
三种循环的区别
*
（for 循环, while 循环）与 （do while 循环）的区别

	* 

for, while 循环都是在条件判断成立的情况下，才执行循环体
*
do while 循环是无论条件判断是否满足，都至少执行一次循环体
*
for 循环与 while 循环的区别

	* 

for 循环的初始化语句中定义的变量，属于 for 结构，只能在 for 结构中或 for 里面使用，出了 for 循环，就访问不到了。

for (int i = 1; i <= 10; i++) {
System.out.println(i); //在 for 循环里面访问没问题
}
System.out.println(i); //出了 for 循环就访问不到了！

	* 

while 循环的初始化语句定义在循环的外部，所以，无论是在循环内部还是出了 while 循环，都可以访问到初始化语句中定义的变量

int i = 1;
while (i <= 10) {
System.out.println(i); //在 while 循环内部可以访问
i++;
}
System.out.println(i); //出了 while 循环也可以访问
死循环
for 循环的死循环格式
for (;😉 {
//循环体语句
}
while 循环的死循环格式
while (true) {
//循环体语句
}
do while 循环的死循环格式
do {
//循环体语句
} while (true);
三种循环如何选择
*
明确循环次数，推荐使用 for 循环
*
不知道循环次数，推荐使用 while 循环
*
死循环，推荐使用 while 循环（代码更清晰）

13、跳转控制语句
break
作用：用于跳出 switch 语句，或者是结束循环
continue
作用：跳过本次循环，继续下一次循环（跳过的效果）

循环嵌套
什么是循环嵌套
循环嵌套，就是在一个循环的里面，再写一个循环
循环嵌套有什么特点
内层循环整体作为外层循环的循环体，外层循环每执行一次，内层循环就要执行一圈！
使用循环嵌套的方式，打印一天内所有的小时+分钟
代码实现
public static void main(Stirng[] args) {
//外层循环控制小时
for (int hour = 0; hour < 24; hour++) {
//内层循环控制风中
for (int minute = 0; minute < 60; minute++) {
System.out.println(hour + “时” + minute + “分”);
}
}
}

随机数
概述
在 Java 程序中生成一个随机数，我们可以使用一个 Java 已经写好的类，这个类叫做 Random。
使用步骤
1.
导包

import java.util.Random;
1.
创建对象

Random r = new Random();
1.
生成随机数

int num = r.nextInt(100); //生成 0 ~ 99 之间的随机数

java基础——IDEA工具&数组

IDEA 安装
什么是 IDE
集成开发环境（Integrated Development Environment，简称 IDE），是将代码编写，编译，执行，调试等多种功能综合到一起的开发工具。
创建项目和模块
1.
打开 IDEA
2.
点击 Create New Project（创建新项目）
3.
选择 Empty Project（空项目）
4.
输入项目名称，选择项目存放位置，点击 Finish（完成）
5.
在弹出的项目结构窗口中添加一个新的模块
6.
在模块的 src（源码目录）下创建包（公司域名倒写）
7.
在包中创建类

编写 HelloWorld 程序，在类中的任意位置单击右键，选择 run xxx.main() 运行程序。

IDEA 项目结构
项目结构说明
*
在 IDEA 中，Project（项目）是最顶级的结构单元
*
一个 Project（项目）中可以有多个 Mudule（模块）
*
一个 Module（模块）中可以有多个 Package（包）
*
一个 Package（包）中可以有多个 Class（类）

Package 说明
*
可以更好地组织和管理我们写的类
*
包机制是为了防止命名冲突
*
如同文件夹结构一样，提供树形的存储方式
*
IDEA 中模块操作
*
新建模块
*
File -> Project Structure -> Modules -> + -> New Module
*
删除模块
*
File -> Project Structure -> Modules -> 选中模块右键点击 -> Remove Module
*
导入模块
*
File -> Project Structure -> Modules -> + -> Import Module

数组，是一个存储数据的容器，可以存储多个相同数据类型的值。
数组的定义格式
*
格式一（推荐）

数据类型[] 数组名;
//举例
int[] arr;
*
格式二

数据类型 数组名[];
//举例
int arr[];
数组的有哪些初始化方式
*
动态初始化
*
静态初始化

动态初始化格式
数据类型[] 数组名 = new 数据类型[数组长度];
//举例
int[] arr = new int[10]; //创建一个 int 类型的数组，数组名叫 arr，数组中可以存储 10 个 int 值
打印数组的结果分析
[I@50cbc42f
[ 表示变量是数组类型
I 表示数组的类型是 int
@ 分隔符
50cbc42f 十六进制的 HashCode 值（暂时理解为内存地址）
数组元素访问
索引，又称角标、下标，是数组中每个元素的位置编号，通过索引可以访问数组中的元素。
注意：索引是从 0 开始的！！！
元素访问格式
数组名[索引];
//举例
int[] arr = new int[5];
System.out.println(arr[0]); //取出并打印数组中的索引为 0 的元素

内存分配
*
栈内存

变量本身，以及基本数据类型的值，存储在栈内存中。
int num = 10;
*
堆内存

引用数据类型（暂时理解为 new 出来的东西），存储在堆内存中。
int[] arr = new int[10];
静态初始化格式
*
完整格式

数据类型[] 数组名 = new 数据类型[]{元素一, 元素二, 元素三…};
//举例
int[] arr = new int[]{1, 2, 3, 4, 5};
*
简化格式（推荐）

数据类型[] 数组名 = {元素一, 元素二, 元素三…};
//举例
int[] arr = {1, 2, 3, 4, 5};
注意事项
数组的初始化，不能动态和静态同时使用！
//错误范例
int[] arr = new int[5] {1, 2, 3, 4, 5};
动态初始化和静态初始化的区别
*
动态初始化

给定数组的长度，数组创建出来后，由系统分配默认的初始值。
*
静态初始化

创建数组时，直接确定数组中的元素，数组的长度由系统计算。
动态和静态初始化如何选择
*
动态初始化

//明确数组中元素的数量，但是不确定具体要存的值，那就使用动态初始化
//举例，键盘录入 5 个学生的成绩
int[] arr = new int[5];
Scanner sc = new Scanner(System.in);
arr[0] = sc.nextInt();
arr[1] = sc.nextInt();
arr[2] = sc.nextInt();
arr[3] = sc.nextInt();
arr[4] = sc.nextInt();
*
静态初始化

//数组中要存储的值已经非常清楚了，那就使用静态初始化
//举例，使用数组存储人民币面额
int[] arr = {1, 2, 5, 10, 20, 50, 100};

数组操作的两个常见问题
索引越界异常
ArrayIndexOutofBoundsException，索引越界异常。当访问了数组不存在的索引时会抛出索引越界异常。
int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr[10]); //ArrayIndexOutofBoundsException
解决方案：改成正确的索引即可
空指针异常
NullPointerException，空指针异常。当某个变量没有记录堆内存中的地址值，此时，通过该变量去访问堆内存中的数据，就会抛出空指针异常。
int[] arr = null; //数组类型的变量 arr 中没有记录任何堆内存地址
System.out.println(arr[0]); //NullPointerException
解决方案：给数组一个真正的堆内存引用即可（指向一个堆内存的数组对象）

数组的遍历
什么是数组的遍历
数组的遍历，就是通过循环，将数组中的所有元素都取出来。
举例
public static void main(String[] args) {
//使用静态初始化的方式创建一个数组
int[] arr = {100, 200, 300, 400, 500};
//使用 for 循环遍历数组
for (int i = 0; i <= 4; i++) {
System.out.println(arr[i]);
}
}
如何获得数组的长度
数组对象有一个属性叫 length，通过这个属性可以获得数组的长度。
举例
public static void main(String[] args) {
//使用静态初始化的方式创建一个数组
int[] arr = {100, 200, 300, 400, 500};
//使用 for 循环遍历数组
for (int i = 0; i < arr.length; i++) { //条件判断语句的 i < 数组长度即可
System.out.println(arr[i]);
}
}
*
能够知道数组的定义格式

数据类型[] 数组名
数据类型 数组名[]
*
能够使用两种方式完成数组元素的初始化

int[] arr = new int[10];
int[] arr = {1, 2, 3, 4, 5};

java基础——方法
*
方法定义和通用格式

方法定义格式
public static void 方法名() {
方法体; //方法体就是方法要做的事情
}
方法调用格式
public static void main(String[] args) {
//调用一个方法
方法名();
}
注意事项
*
方法和方法之间是平级关系，不能嵌套定义。
*
方法定义之后，它并不会自动执行，需要手动调用，才能执行。
*
方法的执行顺序，取决于调用方法的顺序，与方法定义的位置无关。

带参数方法的定义格式
public static void 方法名(数据类型 变量名, 数据类型 变量名…) {
方法体;
}
带参数方法的调用格式
方法名(参数一, 参数二…); //参数的传递可以是常量，也可以是变量
注意事项
*
定义方法时，如果有多个参数，参数和参数之间用逗号分隔。
*
调用方法时，传递的参数数量和类型，要与定义方法时的参数数量和类型保持一致。
*
能够知道形参和实参的区别

形参和实参
什么是形参
形参，全称“形式参数”，是指定义方法时，在方法声明的括号中定义的参数。
public static isEvenNumber(int num) { //int num 就是形参
//…
}
什么是实参
实参，全称“实际参数”，是指调用方法时传递的参数。
public static void main(String[] args) {
isEvenNumber(10); //这里的 10 就是实参
}
带返回值的方法定义格式
public static 返回值类型 方法名(数据类型 变量名, 数据类型 变量名…) {
//方法体
return 返回值;
}
带返回值方法的调用格式
数据类型 变量名 = 方法名(参数一, 参数二…);
注意事项
*
方法中 return 的值的数据类型，要和方法声明的返回值类型一致。
*
方法定义了返回值类型，那么方法的内部必须要返回一个值。
*
在没有定义返回值类型的方法中，也可以使用 return 关键字，作用是结束方法的执行，但 return 后面不能带有具体的值。
*
方法中可以有多个 return 语句，但只会有一个 return 被执行。
*
return 后面不能写代码，因为 return 后面的代码是不可达的

方法的通用格式，可称之为方法的完整格式
public static 返回值类型 方法名(数据类型 变量名, 数据类型 变量名…) {
方法体;
return 返回值;
}
定义方法时，要做到两个明确
1.
明确返回值类型

方法是否需要返回一个执行结果，如果有执行结果要返回，那返回的是什么数据类型的值。
如果方法没有返回值，写 void 即可。
1.
明确参数

方法的执行是否需要调用者提供参数，如果需要，参数的数据类型是什么，以及需要多少个参数。
调用方法
*
无返回值

调用一个没有返回值的方法，不能使用变量接收方法的返回值，也不能在输出语句中调用方法！
有返回值
调用一个有返回值的方法，我们可以使用变量来接收方法的返回值，当然，我们也可以选择不接收，如果不接收，方法仍然会正常执行，只不过方法的返回值被丢弃掉了。
带返回值的方法也可以在输出语句中调用，执行的顺序是先执行方法，再将方法的返回值进行输出。

方法重载
什么是方法重载
方法重载，是指在同一个类中，方法名相同，参数列表不同。
（注意：方法的重载与返回值类型无关！）
参数列表不同
*
参数类型不同
*
参数数量不同
*
参数顺序不同（无意义）

方法参数传递基本数据类型
基本数据类型的参数传递，传递的是值本身，形参的改变，不会影响实参！
方法参数传递引用数据类型
引用数据类型的参数传递，传递的是地址值，形参的改变，会影响实参！
JAVA的基本数bai据类型和引用du数据类型的区别：
1、基本数据类型有：byte：Java中最小的数据类型；shushort：短整型；int：整型；long：长整型；float：浮点型；double：双精度浮点型；char：字符型；boolean：布尔类型。
2、引用数据类型有：类、接口类型、数组类型、枚举类型、注解类型。

3、基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。
而引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。
4、在数据做为参数传递的时候，基本数据类型是值传递，而引用数据类型是引用传递（地址传递）。

java基础——debug，减肥计划，逢七过，不死神兔，百钱百鸡，评委打分，数组元素

debug
什么是 debug
debug 是供程序员使用的调试工具，它可以用于追踪程序的执行流程，从而调试程序。
程序在 debug 模式下运行时，我们可以观察到程序执行每一个步骤，以及程序运行过程中变量中数据的变化。

java基础——面向对象，类和对象，private关键字，this关键字，封装，构造方法

面向对象思想概述
什么是面向过程
面向过程，强调的是过程，是需要自己一步步的完成对应的需求。
自己做一道菜
什么是面向对象
面向对象，强调的是对象，是通过指挥对象去帮助我们完成对应的需求。
请厨师帮我们做一道菜
面向对象的好处
*
面向对象是一种编程思想，它更加符合我们思考问题的一种习惯。
*
将复杂的问题简单化
*
将我们从【执行者】的位置，变成了【指挥者】

2、类和对象
什么是类
类，是一类具有相同属性和行为的事物的抽象。简单理解，类就是对“事物”的“描述”。
任何事物都能够通过属性和行为对其进行描述，以“学生”为例
属性
姓名，性别，年龄，地址
行为
学习，睡觉，吃饭
什么是对象
对象，即客观存在的事物，例如“张三”同学！
类和对象的关系
类是对象的抽象（描述），对象是类的实体。

3、类的定义
编写类的步骤
1.
定义类
2.
编写成员变量（属性）
3.
编写成员方法（行为）

在类中，我们使用成员变量来描述“属性”，使用成员方法描述“行为”
*
成员变量

定义在类中，方法外的变量
*
成员方法

与之前定义方法的格式相同，只不过现在不需要加 static 关键字

对象的使用
对象的创建格式
类名 对象名 = new 类名();
//举例
Phone p = new Phone();
访问成员变量
对象名.成员变量;
//举例
//为对象的成员变量赋值
p.brand = “华为”;
//获取对象的成员变量
System.out.println(p.brand);
访问成员方法
对象名.成员方法名();
//举例
p.call();
p.sendMessage();

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

private 关键字
private 关键字概述
private 关键字是一个访问权限修饰符，它可以用来修饰成员变量和方法。
被 private 修饰的成员有什么特点
被 private 关键字修饰的成员，只能够在类中访问。
在类中使用 private 关键字
我们可以使用 private 关键字修饰类的成员变量，使得成员变量无法被外部直接访问，同时提供外部可以访问到的 set & get 方法。

his 关键字
this 关键字的作用
当成员变量和局部变量重名时，可以使用 this 关键字进行区分，加上 this 关键字的就是成员变量。

this 的内存原理
this 在内存中代表了什么
this 关键字代表当前对象的引用，哪个对象调用方法，方法中的 this 就代表了这个对象的。

13、封装
面向对象的三大特征
*
封装
*
继承
*
多态

封装的原则
将类的某些信息隐藏在类内部，不允许外部直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装是一个比较大的概念
*
私有化成员变量（对类的实现细节进行封装）
*
将一段代码抽取到方法中（对代码进行封装）

封装的好处
封装能够更好的隐藏实现细节，并且能够提高代码的安全性以及复用性。

14、构造方法
构造方法的定义格式
*
构造方法的方法名与类名相同
*
构造方法没有返回值，连 void 也没有
*
public class Person {
*
//构造方法
*
public Person() {
*
//方法体
*
}
*
}
*
构造方法的调用
*
构造方法不能手动调用，当我们创建类的对象时，系统会自动调用类的构造方法
*
构造方法的作用
*
构造方法也可以接收参数，通常情况下，我们可以利用构造方法在创建对象的同时，帮助我们初始化对象的成员变量。
*
public class Person {
*
//成员变量
*
private String name;
*
private int age;
*
//构造方法
*
public Person(String name, int age) {
*
this.name = name;
*
this.age = age;
*
}
*
//getter & setter 略
*
}
*
public class PersonDemo {
*
public static void main(String[] args) {
*
//创建类的对象
*
Person p = new Person(“张三”, 18);
*
}
*
}

构造方法的注意事项
*
构造方法也能够重载
*
如果我们没有在类中写任何的构造方法，编译器会自动添加一个空参的构造方法
*
如果我们在类中手动的写出了构造方法，编译器就不会帮我们添加空参构造方法了

构造方法和成员方法：
构造方法：是一种特殊的方法，主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
　　　　　特别的一个类可以有多个构造方法 ，可根据其参数个数的不同或参数类型的不同来区分它们，即构造方法的重载。
　　主要特点：
　　　　1.名字相同：构造方法的命名必须和类名完全相同。（在java中普通方法可以和构造方法同名，但是必须带有返回值）
　　　　2.无任何返回值：构造方法没有返回值，也不能用void来修饰。
　　　　3.使用new来调用：构造方法不能被直接调用，必须通过new运算符在创建对象时才会自动调用。（而一般的方法是在程序执行到它的时候被调用的）
　　　　4.无显式构造方法时，系统默认无参构造方法：Java编译器会提供一个默认的构造方法.此默认构造方法是不带参数的。(建议手动给出无参构造方法)
注：给成员变量赋值有两种方法：
　　　　1.使用set方法(此方法更常用)；　　2.使用带参构造方法；

赋值方法虽然不同，但调用方法都是相同的，都是使用getXxx。
与一般方法的区别：
　　1.构造方法：对象创建时，就会调用与之对应的构造方法，对对象进行初始化；
　　 一般方法：对象创建后，需要方法功能时才会调用；
　　2.构造方法：对象创建时，会调用且只调用一次；
　　 一般方法：对象创建后，可以被调用多次；
注意：一般方法也可以和类名同名！（为了区分，构造方法首字母大写，而一般方法首字母小写。）

什么时候定义构造方法：
　　在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造方法中。

java基础——API概述，String类，字符串的构造方法，StringBuilder和string相互转换

API 概述
什么是 API
API（Application Programming Interface，简称 API）：应用程序编程接口
我们学习 API，就是在学习如何使用 Java 已经写好的类（JRE 核心类库中有大量已经写好的类）。
API 帮助文档
使用步骤
*
打开帮助文档
*
切换到索引选项卡
*
在输入框中输入我们想要搜索的类
*
查看类在什么包下面 （是否需要导包）
*
查看类的描述 （类是做什么的）
*
查看类的构造方法 （如何创建对象）
*
查看类的成员方法 （如何调用方法）

String 类
String 类的概述
String 类代表字符串，在 Java 程序中，使用双引号括起来的多个字符，都是字符串类的一个实例。
String 类的特点
*
字符串的不可变性

字符串对象一旦创建，对象中的值是不能够被更改的。
public static void main(String[] args) {
//创建一个字符串对象
String s = “aaa”;
s = “bbb”; //这里不是在修改对象中的值，而是让变量 s 重新指向了一新的字符串对象
System.out.println(s);
}
*
字符串的内存共享

字符串对象是可以被共享的
public static void main(String[] args) {
String s1 = “abc”;
String s2 = “abc”;
System.out.println(s1 == s2); //true
}
字符串常量池
JDK6及以前 ：方法区
JDK7 ：堆内存（元空间）
当我们使用直接赋值的方式创建字符串对象时，系统会首先到字符串常量池中查找是否有内容一样的对象，如果有，就直接引用。如果没有，就创建一个，并将创建好的对象的引用放入字符串常量池中。
*
字符串的底层实现

底层存储
JDK8及以前 ：char 数组
JDK9 ：byte 数组
使用 byte 数组来存储，会更节省内存空间！

3、字符串的构造方法

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

public static void main(String[] args) {
//创建一个空白的字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1: " + s1);
//根据字符数组创建字符串对象
char[] chs = {‘a’, ‘b’, ‘c’};
String s2 = new String(chs);
System.out.println("s2: " + s2);
//根据字节数组创建字符串对象
byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println("s3: " + s3);
//根据一个原始的字符串创建字符串对象
String s4 = new String(“abc”);
System.out.println("s4: " + s4);
//直接赋值的方式创建字符串对象
String s5 = “abc”;
System.out.println("s5: " + s5);
}

通过构造方法创建的字符串特点
通过构造方法创建字符串对象，会在堆内存中申请新空间来存储字符串对象，所以，通过构造方法创建的每一个字符串对象都是单独存储在堆内存中的，不存在共享。
以下程序的运行结果是？
public static void main(String[] args) {
//通过构造方法创建字符串对象
String s1 = new String(“abc”);
String s2 = new String(“abc”);
String s3 = new String(“ABC”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
//直接赋值的方式创建字符串对象
String str1 = “a” + “b” + “c”;
String str2 = “ab” + “c”;
String str3 = “abc”;
System.out.println(str1 == str2);
System.out.println(str1 == str3);
}

字符串的比较
== 运算符的作用
*
基本数据类型

使用 == 运算符比较基本数据类型时，比较的是值本身
public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a == b); //true
}
*
引用数据类型

使用 == 运算符比较引用数据类型时，比较的是对象的地址值
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(arr1 == arr2); //false
}
equals 方法的使用
字符串的 equals 方法用于比较两个字符串对象中的内容是相同。
代码示例
public static void main(String[] args) {
//使用构造方法创建两个字符串对象
String s1 = new String(“abc”);
String s2 = new String(“abc”);
System.out.println(s1 == s2); //false，因为 == 比较的是地址值
System.out.println(s1.equals(s2)); //true，因为 equals 比较的是内容
}

String类的常用方法
public char charAt(int index) //获取指定位置的字符
public int length() //获取字符串长度
public boolean equals(Object anObject) //判断两个字符串内容是否相同
public boolean equalsIgnoreCase(String anotherString) //判断两个字符串内容是否相同，忽略大小写
public String substring(int beginIndex, int endIndex) //截取字符串
public boolean contains(CharSequence s) //判断是否包含某个字串

12、StringBuilder（字符串缓冲区）类
StringBuilder 类的介绍
StringBuilder 是一个可变的字符序列，它内部存储的字符串数据是可变的
由于字符串的不可变性，在拼接字符串时，会产生大量的内存垃圾，使用 StringBuilder 类就可以解决这个问题。
StringBuilder 类的构造方法
public StringBuilder() //创建一个空的字符串缓冲区
public StringBuilder(String str) //创建一个带有初始数据的字符串缓冲区
示例
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb1 = new StringBuilder();
System.out.println(“sb1:” + sb1);
//创建一个带有初始数据的字符串缓冲区
StringBuilder sb1 = new StringBuilder(“hello”);
System.out.println(“sb2:” + sb2);
}

StringBuilder 的添加和反转
添加方法
创建好 StringBuilder 对象之后，我们可以通过 append 方法添加数据到缓冲区中。
public StringBuilder append(任意数据类型)
示例
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据
sb.append(“Hello”);
sb.append(“World”);
System.out.println(sb); //HelloWorld
}
StringBuilder 类的 append 方法还支持链式编程
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据（链式编程）
sb.append(“Hello”).append(“World”);
System.out.println(sb);
}
反转方法
要反转字符串缓冲区中的内容，可以调用 StringBuilder 类的 reverse 方法
public StringBuilder reverse() //反转字符串缓冲区中的内容
示例
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据
sb.append(“12345”);
//反转
sb.reverse();
System.out.println(sb); //54321
}

StringBuilder 的添加和反转
添加方法
创建好 StringBuilder 对象之后，我们可以通过 append 方法添加数据到缓冲区中。
public StringBuilder append(任意数据类型)
示例
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据
sb.append(“Hello”);
sb.append(“World”);
System.out.println(sb); //HelloWorld
}
StringBuilder 类的 append 方法还支持链式编程
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据（链式编程）
sb.append(“Hello”).append(“World”);
System.out.println(sb);
}
反转方法
要反转字符串缓冲区中的内容，可以调用 StringBuilder 类的 reverse 方法
public StringBuilder reverse() //反转字符串缓冲区中的内容
示例
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据
sb.append(“12345”);
//反转
sb.reverse();
System.out.println(sb); //54321
}

StringBuilder 和 String 的转换
StringBuilder 转 String
public static void main(String[] args) {
//创建空的字符串缓冲区
StringBuilder sb = new StringBuilder();
//添加数据
sb.append(“Hello”);
//StringBuilder 转换成 String
String str = sb.toString();
System.out.println(str);
}
String 转 StringBuilder
public static void main(String[] args) {
//创建一个字符串
String str = “Hello”;
//String 转 StringBulder
StringBuilder sb = new StringBuilder(str);
System.out.println(sb);
}

java基础——ArrayList集合&学生管理系统 ——ArrayList类的构造方法，ArrayList

ArrayList 集合的介绍
什么是 ArrayList 集合
集合，是存储数据的容器，ArrayList 是众多集合类中最常用的一种。
ArrayList 集合的特点
*
ArrayList 的长度是可变的
*
ArrayList 底层是由数组实现的

2、ArrayList 类的构造方法和添加方法
构造方法
public ArrayList() //创建一个空的集合
添加方法
public boolean add(E e) //添加一个元素到集合的末尾
示例
public static void main(String[] args) {
//创建集合对象
ArrayList list = new ArrayList<>();
//添加元素
list.add(“张三”);
list.add(“李四”);
//打印集合中的元素
System.out.println(list);
}
什么是泛型
泛型，现在我们可以将其理解为，用于限制集合中可以存储的数据类型！
包装类型
由于泛型不支持基本数据类型，Java 为基本数据类型都提供了对应的包装类型
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
要在集合中存储基本数据类型的数据，我们可以将泛型设置为对应的包装类型

3、ArrayList常用方法
public boolean add(E e) //向集合中添加元素
public void add(int index,E e) //向集合中指定索引处添加元素
public boolean remove(Object obj) //删除集合中指定元素
public E remove(int index) //删除集合中指定索引处的元素
public E set(int index,E e) //修改集合中指定索引处的元素
public E get(int index) //获取集合中指定索引处的元素
public int size() //获取集合的长度
1.ArrayList
1.1ArrayList类概述【理解】
什么是集合 提供一种存储空间可变的存储模型，存储的数据容量可以发生改变 ArrayList集合的特点 底层是数组实现的，长度可以变化 泛型的使用 用于约束集合中存储元素的数据类型
1.2.1构造方法
方法名 说明
public ArrayList() 创建一个空的集合对象
1.2.2成员方法
public boolean remove(Object o) 删除指定的元素，返回删除是否成功
public E remove(int index) 删除指定索引处的元素，返回被删除的元素
public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
public E get(int index) 返回指定索引处的元素
public int size() 返回集合中的元素的个数
public boolean add(E e) 将指定的元素追加到此集合的末尾
public void add(int index,E element) 在此集合中的指定位置插入指定的元素
1.2.3示例代码
public class ArrayListDemo02 { public static void main(String[] args) { //创建集合 ArrayList array = new ArrayList();
//添加元素 array.add(“hello”); array.add(“world”);
1.3ArrayList存储字符串并遍历【应用】 1.3.1案例需求
创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合 1.3.2代码实现
array.add(“java”);
//public boolean remove(Object o)：删除指定的元素，返回删除是否成功 // System.out.println(array.remove(“world”)); // System.out.println(array.remove(“javaee”));
//public E remove(int index)：删除指定索引处的元素，返回被删除的元素 // System.out.println(array.remove(1));
//IndexOutOfBoundsException // System.out.println(array.remove(3));
//public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素 // System.out.println(array.set(1,“javaee”));
//IndexOutOfBoundsException // System.out.println(array.set(3,“javaee”));
//public E get(int index)：返回指定索引处的元素 // System.out.println(array.get(0)); // System.out.println(array.get(1)); // System.out.println(array.get(2)); //System.out.println(array.get(3)); //？？？？？？ 自己测试
//public int size()：返回集合中的元素的个数 System.out.println(array.size());
//输出集合 System.out.println(“array:” + array); } }