java知识点复习新政版

Java源文件是编写Java程序的文本文件，通常以 .java 为后缀名。一个Java源文件（ .java ）中最多只能有一个 public 修饰的类，且该类的名称必须与源文件名完全一致（包括大小写）。
object9.library 是一个包（package）其中包含了 operation(操作) ， user（用户）两个包 operation 中放了可执行操作（类 c，接口 I） user 中为用户的身份管理员或普通用户

A.java

public class A { }
public class B { } // 编译错误：源文件中只能有一个public类

字节码文件 .class

由Java源文件（ .java ）通过 javac 编译生成
javac - 将Java源文件（ .java ）编译为字节码文件（ .class ），供Java虚拟机（JVM）执行。

数据类型：

类型分类	类型名称	字节数	泛型对应包装类	取值范围
整数型	`byte`	1 字节	`Byte`	-128 至 127
整数型	`short`	2 字节	`Short`	-32768 至 32767
整数型	`int`	4 字节	`Integer`	-2¹⁵ 至 2¹⁵-1（-32768 至 32767）
整数型	`long`	8 字节	`Long`	-2³¹ 至 2³¹-1（-2147483648 至 2147483647）
浮点型	`float`	4 字节	`Float`	±1.4E-45 至 ±3.4028235E+38（科学计数法）
浮点型	`double`	8 字节	`Double`	±4.9E-324 至 ±1.7976931348623157E+308
字符型	`char`	2 字节	`Character`	`\u0000`（0）至 `\uFFFF`（65535）
布尔型	`boolean`	1 字节 *	`Boolean`	`true` 或 `false`

数据类型转换

自动转换

取值范围小的转的大精度低的转精度大的

一、数据类型按取值范围从小到大排序

1.  byte （-128~127，1字节）

2.  short （-32768~32767，2字节）

3.  char （0~65535，2字节，无符号）

4.  int （-2¹⁵~2¹⁵-1，4字节）

5.  long （-2³¹~2³¹-1，8字节）

6.  float （±1.4E-45~±3.4028235E+38，4字节，单精度）

7.  double （±4.9E-324~±1.7976931348623157E+308，8字节，双精度）

源类型（小范围 / 低精度）	目标类型（大范围 / 高精度）
`byte`	`short/int/long/float/double`
`short`	`int/long/float/double`
`char`	`int/long/float/double`
`int`	`long/float/double`
`long`	`float/double`
`float`	`double`

强制转换

小范围、低精度转大范围大精度

eg: Float floatVar = 3.14f;
int intVar = (int)floatVar; // 强制转换Float→int

直接截断小数部分，不进行四舍五入：
(int)3.14f → 3

源类型（大范围 / 高精度）	目标类型（小范围 / 低精度）
`short/int/long/float/double`	`byte`
`int/long/float/double`	`short`
`long/float/double`	`int`
`float/double`	`long`
`double`	`float`
`int/long/float/double`	`char`

自增自减运算符

运算符	形式	执行逻辑	返回值	示例（假设 i=5）
自增	前缀`++i`	先将 i 加 1，再使用 i 的新值	加 1 后的值	`j = ++i` → i=6，j=6
自增	后缀`i++`	先使用 i 的当前值，再将 i 加 1	加 1 前的原值	`j = i++` → i=6，j=5
自减	前缀`--i`	先将 i 减 1，再使用 i 的新值	减 1 后的值	`j = --i` → i=4，j=4
自减	后缀`i--`	先使用 i 的当前值，再将 i 减 1	减 1 前的原值	`j = i--` → i=4，j=5

关系运算符：

> , < , >=, <= , == , !=

逻辑运算符

&& 逻辑与， || 逻辑或，！逻辑取反

以上两种运算符与C语言中不同的是返回值为 true 或 false 不是 1 ， -1 ， 0

if（a > b）{} a > b 为真的情况返回 true 进入 if 的代码块 { } 反之跳过
while(!a > b) a > b 为真的情况返回 true 但逻辑取反！变为 false 不进入循环
a > b 为假的情况返回 false 但逻辑取反！变为 true 进入循环

开关语句：

执行过程：当switch后表达式的值和case语句后的值相同时，从该位置开始向下执行，直到遇到break语句或者switch语句块结束；如果没有匹配的case语句则执行default块的代码。

case 后加：不是；

package step4;

import java.util.Scanner;

public class HelloSwitch {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入月份：");
		
		int input = sc.nextInt();	//获取输入的月份
		
        //通过输入的月份来判断当前季节并输出
		/*****start*****/
		switch(input){
            case 3:
            case 4:
            case 5:
            System.out.println(input + "月是春天");
            break;
            case 6:
            case 7:
            case 8:
            System.out.println(input + "月是夏天");
            break;
            case 9:
            case 10:
            case 11:
            System.out.println(input + "月是秋天");
            break;
            case 12:
            case 1:
            case 2:
            System.out.println(input + "月是冬天");
            break;

            default:
                System.out.println("输入的月份无效，请输入 1 - 12 之间的整数");

        }

认识类

类

class 类名{
// 成员变量
  成员变量 a; private/public/protected 变量名；
  成员变量 b;

// 构造方法初始化的作用
public 类名（参数：可以没有或成员变量a,成员变量b）{
this.a = a;
this.b = b;
}

// 方法体 Getter Setter
public 返回值类型 getA (){
return a;
}
public void setA(成员变量 a){
this.a = a;
}
public 返回值类型 getB (){
return a;
}
public void setB(成员变量 b){
this.a = b;
}

// 主方法
public static void main (String[] args){
}

}

构造方法

一个实例

public class MyDate {
    public int year;
    //public int year = 2024；  就地初始化
    public int month;
    //public int month = 11;    就地初始化
    public int day;

   //代码块
//    {
//        year = 2024;
//        month = 11;
//        day = 21;
//          System.out.println("代码块初始化");
//    }

    //构造方法   一旦带有 void 就变为普通方法了
    public MyDate() {
        year = 2024;
        month = 11;
        day = 21;
        System.out.println("调用构造方法");
        //允许使用构造方法调用其他构造方法
       // this(2024,11,21);  this 只能做第一行代码

    }


    //    public void setDate(int y , int m ,int d){
//        year = y;
//        month = m;
//        day = d;
//    }
    public void setDate(int year , int month ,int day){
        // 优先将 year 作为形参 通过 this 关键字表明哪些是成员变量 特殊的引用 只能在方法中使用
        this.year = year;
        this.month = month;
        this.day = day;

    }
    public MyDate(int year, int month , int day){
        this.year =  year;
        this.month = month;
        this.day = day;
        System.out.println("调用第二个构造方法");

    }
    //this = new Date();  错误 this不是变量不能修改

    public void printDate(){
        System.out.println(year + "." + month + "." + day);
    }

    @Override    //在一个方法或类上 添加@  注解
    public String toString() {
        return "Date{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    public static void main(String[] args) {
 //       Date date = new Date();// 只是对 date 初始化了   int year int month int day 还未初始化 通过构造方法初始化  1.构造方法的方法名，必须和类名一致并且不能有返回值  2 new 对象时自动调用
//        date.setDate(2024, 11 ,21);  // 这样的方法调用，在编译器底层看到的效果： public void setDate(Date this, int year,int month, int day)
        MyDate date = new MyDate(2024,11,21);
        date.printDate();
    }
}
        //允许使用构造方法调用其他构造方法

另一个实例

public class Book {
    //书名
    private String name;
    //作者
    private String author;
    // 类型
    private String type;
    // 价格
    private double price;
    // 是否借出
    private boolean isBorrowed;

    // 构造方法
    public Book(String name, String author, String type, double price) {
        this.name = name;
        this.author = author;
        this.type = type;
        this.price = price;
        this.isBorrowed = false; // 默认未借出
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public double getPrice() {
        return price;
    }

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

    public boolean isBorrowed() {
        return isBorrowed;
    }

    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }

    @Override
    public String toString() {
//        return "Book{" +
//                "name='" + name + '\'' +
//                ", author='" + author + '\'' +
//                ", type='" + type + '\'' +
//                ", price=" + price +
//                ", isBorrowed=" + isBorrowed +
//                '}';
         return  "[" + name + "，" + author + "，" + price + "，" + type + "，" + (isBorrowed ? "已借出" : "在库中") + "]";
    }
}

创建对象

类名对象名 = new 类名；

eg: Scanner a = new Scanner(System.in); new 一个实例出来
就像在饭店吃饭类是菜单 new 是点单的行为对象即菜

public Book(String name, String author, String type, double price) {
this.name = name;
this.author = author;
this.type = type;
this.price = price;
this.isBorrowed = false; // 默认未借出
}
上面那个 Book book = new Book("《java从入门到精通》" ，“肘子” ， “教材”，“100.00”)；

name 书名 author 作者 type 书的类型 price 价格

括号内：类的构造方法括号里的参数若没有（即无参构造函数）可以不写

调用类中方法

对象名 . 方法； “. ”点运算符
以Book 类为例

Book book = new Book("java从入门到精通" ，“肘子” ， “教材”，“100.00”)；

String bookName = book.getName();

System.out.printfln(bookName); // 结果《java从入门到精通》

类成员、类方法 static

关键词 static eg: static int x; 静态成员/ 类成员
static void text() {} 静态方法/ 类方法
注意：类成员可以用类名访问不创建对象
类方法- 1.不能访问非static成员
2. 内部不能使用 this
3. 全局仅执行一次

3. 全局仅执行一次

static 不能修饰构造方法选项中 this super 也可记下

1.不能访问非static成员

继承，接口

继承 extends 接口 implements Object 是所有类的父类（祖宗）

继承：一个类可以有多个子类，但只能有一个父类
final 关键字修饰的类不能被继承且 final 修饰的方法不能被重写 final 修饰的变量不能被修改
区别接口：一个类可以实现多个接口

public interface MyInterface { /* 接口内容 */ }

可定义 抽象方法（JDK 7 及以前默认 public abstract ，可省略修饰符）、默认方法（default 修饰，带方法体）、静态方法（static 修饰，带方法体）、常量（默认 public static final ，必须赋值）。

接口继承接口：用 extends 关键字，支持多继承

interface SubInter extends InterA, InterB { }

接口成员规则对比表

成员类型	语法示例	核心特性	实现类 / 子类处理方式
抽象方法	`void doTask();`	隐式 `public abstract` 修饰（可省略）无方法体，仅声明行为规范	非抽象类必须重写；抽象类可选择不重写，留待子类实现。
默认方法（JDK 8+）	`default void showMsg() { System.out.println("默认提示"); }`	用 `default` 修饰，必须包含方法体为接口提供默认实现逻辑，不强制实现类修改	实现类可直接继承使用，也可重写覆盖。
静态方法（JDK 8+）	`static void log() { System.out.println("日志记录"); }`	用 `static` 修饰，必须包含方法体只能通过接口名调用（如 `MyInterface.log()`）	实现类无法继承或重写，需通过接口名直接调用。
常量	`String VERSION = "1.0";`（等价于 `public static final String VERSION = "1.0";`）	隐式 `public static final` 修饰（可省略）值必须固定，不可修改	接口和实现类均可通过 `接口名.常量名` 访问。

接口中声明的属性，会自动隐含 public static final 修饰符。

interface MyInterface {
// 等价于 public static final int NUM = 10;
int NUM = 10;
}

接口中的私有方法：有普通私有（private ）归默认方法调用，静态私有（private static）归静态方法调用。接口中默认方法，静态方法都必须有方法体。所以私有也得有

//  父类  且为抽象类  abstract

public abstract class User {
    protected String name;
    public User (String name){
          this.name = name;
{

    // 显示用户菜单，返回值为用户输入的序号
    public abstract int menu();    // 抽象方法 必须在子类中重写（除非子类同为抽象类）

}

//子类 Admin （管理员类） extends (继承自）User (用户类）

public class Admin extends User{

    public Admin(String name) {
        super(name);  //  通过 super 调用父类有参构造方法
        operations = new IOperation[] {
                new ExitOperation(),// 0
                new ListOperation(),// 1
                new FindOperation(),// 2
                new AddOperation(), // 3
                new DelOperation()  // 4
        };
    }

    @Override  // 重写抽象方法
    public int menu() {  // 与 int menu(); 保持一致
        // 打印管理员的菜单
        System.out.println("*********************************");
        System.out.println("欢迎您," + name);
        System.out.println("1.查看书籍列表");
        System.out.println("2.按照名字查找书籍");
        System.out.println("3.添加新书");
        System.out.println("4.删除书籍");
        System.out.println("0.退出");
        System.out.println("*********************************");
        System.out.println("请输入您的选项");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

`super`调用的规则与细节

1. 隐式 vs 显式调用

隐式调用：若子类构造方法中省略super(...)，编译器会自动插入super()（即调用父类的无参构造）。
```
public Admin(String name) {
    // 隐式调用super()，等价于：
    // super();  // 必须在第一句

}
```
显式调用：当父类没有无参构造方法时，必须显式调用父类的其他构造方法。

方法重载，重写

重载@overload : 指同一类中多个方法同名，但参数列表不同（参数数量、类型或顺序不同），编译器会根据调用时的参数自动匹配对应方法。

. 必须满足的条件

1- 方法名相同：如 calculate() 。

2- 参数列表不同（至少满足以下一项）：

3- 参数数量不同：如 calculate(int a) 和 calculate(int a, int b) 。

4- 参数类型不同：如 calculate(int a) 和 calculate(double a) 。

5- 参数顺序不同：如 calculate(int a, double b) 和 calculate(double a, int b) 。

6- 返回值类型、访问修饰符无关：即使返回值不同，只要参数列表不同就构成重载（但仅返回值不同不能重载）。

重写 @override：是子类对父类同名方法的重新实现，体现了“运行时多态”特性。
必须满足的条件

1- 子类继承父类或实现接口。

2- 方法名、参数列表、返回值类型完全相同（例外：子类返回值类型是父类返回值的子类）。

3- 子类方法的访问修饰符不能比父类更严格（如父类方法是 protected ，子类不能是 default ）。

例题

封装

把对象的属性（成员变量）和实现细节藏起来，通过公共方法（getter/setter）对外提供访问，让外部无法直接修改内部状态

Java 用 访问修饰符 控制类成员的可见范围，常用的有：

修饰符	可见范围	典型场景
`private`	仅当前类可见	隐藏核心属性上面Book 类的 name .... 都用了private 提供了 getter setter 写法见上
`default`	同包可见（不写修饰符时默认）	包内工具类的内部协作
`protected`	同包 + 子类可见	父类给子类开放的扩展入口
`public`	所有类可见	对外暴露的核心功能（如`main`方法）

String 类

1. 不可变性：对象创建后内容不可修改，修改操作会生成新对象

2. 创建方式：

1.类似 String str = "abc"，字符串入常量池，相同内容复用。

2.String str = new String("abc");

3. 字符串拼接：

+  拼接， int a = 123 int b = 456 a + ""

4. 比较方式：

- equals()  比较内容， ==  比较对象引用。
String s1 = new String("a");
String s2 = new String("a");
System.out.println(s1 == s2); // false s1 s2 引用（地址不同）
System.out.println(s1.equals(s2)); // true s1 s2 内容都是 “a”

- compareTo()  按字典序比较，返回差值。从左到右一个字符一个字符比 ASCII 码

5. 常用方法： length()  获长度、 charAt(index)  取指定字符、 substring()  截取子串、 toLowerCase() / toUpperCase()  转大小写、 split()  按规则拆分、 replace() / replaceAll()  替换等。

6. 与 StringBuilder、StringBuffer 区别： String  不可变，后两者可变，前者线程不安全、效率高，后者线程安全、效率稍低，大量拼接选后两者。

拼接 1 创建 StringBuffer stringBuffer = new StringBuffer();
2 调方法 s.append("要拼接的字符串")；

7. 注意空值与空字符串： null 表示无对象， "" 是有对象但内容空，调用方法前需判空，避免空指针异常。

异常

受查异常（编译时异常，必须处理）

异常类名	说明
`IOException`	输入输出操作异常（如文件不存在、读写失败）
`SQLException`	数据库操作异常（如 SQL 语法错误、连接失败）
`ClassNotFoundException`	类未找到异常（如通过反射加载类时类不存在）
`InterruptedException`	线程中断异常（如线程等待时被中断）
`FileNotFoundException`	文件未找到异常（如访问不存在的文件路径）

非受查异常（运行时异常，无需显式处理）

异常类名	说明
`NullPointerException`	空指针异常（访问 null 对象的方法或属性）
`ArrayIndexOutOfBoundsException`	数组越界异常（访问不存在的数组索引）
`ClassCastException`	类型转换异常（如将 Object 强制转换为不兼容类型）
`IllegalArgumentException`	非法参数异常（如方法传入无效参数）
`ArithmeticException`	算术异常（如除以 0）
`IllegalStateException`	状态异常（如集合已修改时迭代）
`IndexOutOfBoundsException`	索引越界（如 String、List 访问不存在的索引）
`NumberFormatException`	数字格式异常（如`Integer.parseInt("abc")`）

异常处理关键字与语法

关键字	作用
`try`	包裹可能抛出异常的代码块
`catch`	捕获并处理特定类型的异常
`finally`	无论是否发生异常，都会执行的代码块（常用于资源关闭）
`throw`	在方法中手动抛出异常对象
`throws`	方法声明时抛出异常，由调用方处理

代码结构

//        try{
//           可能发生异常的代码
//        }catch(){
//           处理异常（打印异常信息）
//        }finally{  //  无论上方的 try 是否抛出异常
//                       此处的 finally 都是会执行的 （收尾工作）
//        }

输入输出流

需要导入包 import java.io*;

一、字节流与字符流体系

1. 字节流（处理二进制数据）

- FileInputStream ：从文件读字节数据，构造方法传文件路径， read  方法读字节（返回 -1 表示读完）。

- FileOutputStream ：向文件写字节数据，构造方法可传 (路径, true)  实现追加（默认覆盖）。

- DataOutputStream ：搭配其他输出流，写基本数据类型（writeInt 、 writeDouble  ）。

2. 字符流（处理文本数据）

- FileReader ：从文件读字符，适合文本文件， read  方法读字符或字符数组。

- FileWriter ：向文件写字符，默认覆盖

二、缓冲流（提升读写效率）

- BufferedInputStream / BufferedReader ：构造方法需传入基础字节流/字符流（如 FileInputStream / FileReader  ），通过缓冲区减少 IO 次数。

三、文件与目录操作

- isDirectory() ： File  类方法，判断 File  对象是否表示目录。

- RandomAccessFile ：支持随机访问文件，可灵活读写文件任意位置（如 seek  跳转、 read/write  随机读写）。

四、异常与资源管理

- 流操作会抛 IOException （如文件不存在抛 FileNotFoundException  ），需用 try-catch  捕获或 throws  声明。

import java.io.*; // 导入 IO 相关类

public class Example10_4 {
    public static void main(String args[]) {
        int n = -1; // 用于存储每次读取的字节数
        byte[] a = new byte[100]; // 缓冲区，每次最多读 100 字节

        try {
            // 1. 创建 File 对象，关联要读取的文件
            File f = new File("Example10_4.java"); 
            // 2. 创建文件字节输入流（字节流，读二进制数据）
            FileInputStream in = new FileInputStream(f); 

            // 3. 循环读取：read(a, 0, 100) 读入字节数组，返回实际读取的字节数
            while ((n = in.read(a, 0, 100)) != -1) { 
                // 4. 将字节数组转为字符串（从 0 开始，取 n 个字节）
                String s = new String(a, 0, n); 
                // 5. 输出字符串内容（拼接显示文件内容）
                System.out.print(s); 
            }

            in.close(); // 6. 关闭流
        } catch (IOException e) { 
            // 7. 捕获 IO 异常（文件不存在、读写失败等）
            System.out.println("File read Error" + e); 
        }
    }
}

import java.io.*; // 导入 IO 相关类

public class Example10_5 {
    public static void main(String args[]) {
        // 1. 将字符串转为字节数组
        byte[] a = "国庆 70 周年".getBytes(); 
        byte[] b = "十一快乐".getBytes(); 

        try {
            // 2. 创建文件字节输出流（关联文件 happy.txt，默认覆盖内容）
            FileOutputStream out = new FileOutputStream("happy.txt"); 
            out.write(a); // 3. 写入字节数组 a（完整内容）
            // 4. 写入字节数组 b（从索引 0 开始，写 b.length 个字节）
            out.write(b, 0, b.length); 
            out.close(); // 5. 关闭流
        } catch (IOException e) { 
            // 6. 捕获 IO 异常
            System.out.println("Error " + e); 
        }
    }
}

垃圾回收 gc （from 肘子秘籍）

Java是自动内存管理语言，垃圾回收由JVM的GC机制自动执行，无需程序员手
动释放内存。
核心原则：GC负责识别并回收不再被引用的对象所占用的内存。

程序员无法直接干预GC的执行时机，只能通过`System.gc()建议GC运行，但
JVM不一定立即执行。
不存在“指定时间释放内存对象”的编程接口，GC的触发时机由JVM内部策略决
定（如内存阈值、对象存活时间等）。

总结：Java 的 GC 是“自动、智能、难干预”的内存回收机制：自动识别无用对象，回收时机由 JVM 自己定，程序员只能建议（ System.gc() ），但不一定被采纳。

命名规范

分类	具体规则	示例（正确 / 错误对比）
允许字符	字母（A - Z、a - z）、美元符号（$）、下划线（_）、数字（0 - 9，不能开头）	正确：`studentName`、`_id`、`price\$10` 错误：`1num`（数字开头）
不建议内容	中文但可以	class 人{}
大小写规则	严格区分大小写，`Name` 和 `name` 是不同标识符	正确：`UserDao` `userService`
关键字避免	禁止使用 Java 关键字（`int`/`class`/`while` 等）作为标识符	错误：`int`（变量名用 `count` 替代）
类名规范	大驼峰（每个单词首字母大写，无连接符）	如： User Admin
方法、变量名规范	小驼峰（首单词小写，后续单词首字母大写），描述行为 / 属性	如：`calculateTotal()` `productPrice`
常量名规范	全大写，单词间用下划线分隔，强调不可变性	如：`MAX_RETRY` `DEFAULT_TIMEOUT`

数组

java 数组

创建： int [ ] arr = {1,2,3};

int arr [ ] = {1,2,3};

int [ ] arr = new int [3];

int arr[ ] = new int [3];

数组下标：

eg:

int[] arr = {10, 20, 30};
arr[0] = 10; // 第一个元素
arr[2] = 30; // 第三个元素（最大索引 2 = 长度 3 - 1）

int len = arr.length; // 获取数组长度 3

数组遍历

for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}

// for-each 遍历
for (int num : nums) {
System.out.println(num);
}

二维数组声明：
1. int[][] arr = {{3,3}};
2. int[][] arr = new int[3][4]；3行4列
3. int[][] arr = new int[3][] 3行，暂不配列数
后会为每行分配列数
arr[0] = new int[2] 第1行2列
arr[1] = new int[3] 第2行3列

核心思想双指针：

结果： [4,5,3,1,2]

代码实现

//  核心思想

public void reverseArray (int[] arr){
   
int left = 0;
int right = arr.length - 1;

while(left < right){
    int tmp = arr[left];
    arr[left] = arr[right];
    arr[right] = tmp;
    left ++;
    right --;
   
}

泛型，集合类

import java.util.*;

public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        List<Integer> list = new ArrayList<Integer>();
        while (sc.hasNext()) {
            list.add(sc.nextInt());
        }
        
 // list数组反转
        int left = 0;
        int right = list.size() - 1;
        while(left<right){
            Integer tmp = list.get(left);
            list.set(left,list.get(right));
            list.set(right,tmp);
            left++;
            right--;
        }
  // 循环输出list数组元素
        for(int i = 0; i < list.size(); i++){
            //System.out.println(Arry.toString(list);
            System.out.print(list.get(i) + " "); 
        }

    }
}

题目给了list，创建了一个线性表并实现了多组输入通过list.add()方法将数组元素入表

此时数据类型变成了Integer 所以创建交换变量(tmp)时应使用这个作为数据类型

list.get(）获取right的值

list.set() 将 right的值赋给 left 将 right 设为 tmp (即left的值) 交换完成

left++ 指针向后走一步 right-- 指针向前走一步

list.size() 获取元素个数

包装类

基本类型	包装类
`byte`	`Byte`
`short`	`Short`
`int`	`Integer`
`long`	`Long`
`float`	`Float`
`double`	`Double`
`char`	`Character`
`boolean`	`Boolean`

集合类 List

一个接口类型，表示有序、可重复的集合

实现类	底层结构	基础方法
`ArrayList`	动态数组	.add() .remove() .set() .get() 增删改查 .size() 元素个数
`LinkedList`	双向链表	.add() .remove() .set() .get() 增删改查 .size() 元素个数

创建：List<Integer> list = new ArrayList<Integer>();

Integer：泛型参数，指定列表元素类型为包装类 Integer 写 <> 里面后一个可省略

List<Integer> list = new ArrayList<>();

未完待续......

我看见半晴天好刺眼好刺眼它讲别怕往前 ———— DT 《半晴天》

本文章已经生成可运行项目