Java 复习摘要

一.选择与控制结构

①if语句（流程控制语句--分支结构）

1）含义

if语句是单条件分支语句，即根据一个条件来控制程序执行的过程

2）语法格式

if(表达式){
    若干语句;
}

3）流程图

4）例子

public class Example {
    public static void main(String[] args){
        int a=9,b=5,c=7,t=0;
        if(b<a){
            t=a;
            a=b;
            b=t;
        }
        if(c<a){
            t=a;
            a=c;
            c=t;
        }
        if(c<b){
            t=b;
            b=c;
            c=t;
        }
        System.out.println("a="+a+",b="+b+",c"+c);
    }
}

②if....else语句

1）含义

单条件分支语句，即根据一个条件来控制程序执行的流程

2）语法格式

if(表达式){
    若干语句;
}else{
    若干语句;
}

3）流程图

4）例子

public class Example {
    public static void main(String[] args){
        int math = 65,english = 85;
        if(math>60){
            System.out.println("数学及格了");
        }else{
            System.out.println("数学不及格");
        }
​
        if(english>90){
            System.out.println("英语成绩优秀");
        }else{
            System.out.println("英语成绩不是优秀");
        }
        System.out.println("我在学习if...else语句");
    }
}

###

③if...else if...else语句

1）含义

多条件分支语句，即根据多个条件来控制程序执行的流程

2）格式

if(表达式){
    若干语句;
}else if(表达式){
    若干语句;
    .
    .
    .    
}else{
    若干语句;
}

3)流程图

4）例子

public class Example {
    public static void main(String[] args) {
        int score = 75;
​
        if (score >= 90) {
            System.out.println("等级：A");
        } else if (score >= 80) {
            System.out.println("等级：B");
        } else if (score >= 70) {
            System.out.println("等级：C");
        } else if (score >= 60) {
            System.out.println("等级：D");
        } else {
            System.out.println("等级：F");
        }
    }
}

④for语句

1）含义

编程语言中的一种循环控制结构，广泛用于需要重复执行某段代码直到满足特定条件停止的场景。它提供了一种紧凑的方式来初始化循环变量、测试循环条件以及更新循环变量的值，所有这些都在一个语句中完成。for循环特别适合于当循环的迭代次数在开始时就已经确定或者可以根据某些规律推算出来的情况。

2）语法格式

for(表达式1;表达式2;表达式3){
    若干语句
}

3）流程图

4）例子

A.计算1-5之间的数据之和，并输出总和；
    public class Example{
   public static void main(String[] args){
     int sum = 0;
     for(int i=1; i<=5;i++){
       sum+=i;
     }
     System.out println(sum);
   }
}
​
B.打印水仙花数（指一个三位数，其各位数字的立方等于该数本身）
    public class Main{
   public static void main(String[] args){
      
      for(int i = 100;i<1000;i++){
         int a = i%10;
         int b = i/10%10;
         int c = i/100;
         if(a*a*a+b*b*b+c*c*c==i){
            System.out.println(i);
         }
      }
   }
}
​

⑤多重循环嵌套

1）含义

多重循环嵌套指的是在一个循环内部再包含另一个循环（或更多循环）的结构。这种结构允许你在多个维度上进行迭代，非常适合处理多维数组、矩阵操作或是更复杂的逻辑判断。每个内部循环都可以独立地完成自己的迭代过程，而外部循环控制整体的迭代次数或范围。

2）语法格式

for (初始化外层; 条件外层; 更新外层) {
    for (初始化内层; 条件内层; 更新内层) {
        // 循环体代码，这里是内层循环执行的部分
    }
    // 可能还有其他位于内层循环结束后，外层循环体内的代码
}

3）例子

A.九九乘法表

public class Example{
    public static void main(String[] args) {
//九九乘法表
        for(int i = 1;i <= 9;i++){
            for(int j = 1;j <= i;j++){
                System.out.print(i + "*" + j + "=" + i*j + " ");
            }
            System.out.println(); //换行
        }
    }
}

B.100以内的质数

public class Example {
    public static void main(String[] args) {
        boolean isFlag = true; //标识是否被除尽，一旦除尽，修改其值。
        for (int i = 2; i <= 100; i++) { //遍历100以内的自然数
            for (int j = 2; j < i; j++) { //j:被i去除 这里写 j < i/2 会更好
                if (i % j == 0) { //i被j除尽
                    isFlag = false;
                }
            }
            if(isFlag == true){
                System.out.print(i+" ");
            }
//重置isFlag
            isFlag = true;
        }
    }
}

C.直角三角形
public class Example {
    public static void main(String[] args) {
        for(int i = 1;i<6;i++) {//外循环
            for (int j = 1; j <=i; j++) {//内循环
                System.out.print("*");
            }
            System.out.println();//空白行用来换行
        }
    }
}

二.枚举算法

①枚举的预备知识

1）Java枚举（enum）

表示一个特殊的类，一般表示一组常量，比如一年的四个季节，一个年的12月份，一个星期的七天等等

(注意：Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。枚举类和正常类一样，也可以有成员变量、实例方法、静态方法、抽象方法。)

2）代码格式

enum 枚举名{
    常量列表
}

3）例子

//定义一个表示一年四季的枚举量
//每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。
enum Season {
    spring,summer,autumn,winter;
}

public class Example {
    public static void main(String[] args){
        Season s1 = Season.spring;
        System.out.println(s1);
    }
}

4）enum 定义的枚举类

方法	作用
values()	返回枚举类中所有的值
ordinal()	找到每个枚举常量的索引
valueOf()	返回指定字符串值的枚举常量

(默认继承了 java.lang.Enum 类，并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口。)

5）枚举类中定义抽象方法

enum Color{
    RED{
        public String getColor(){//枚举对象实现抽象方法
            return "红色";
        }
    },
    GREEN{
        public String getColor(){//枚举对象实现抽象方法
            return "绿色";
        }
    },
    BLUE{
        public String getColor(){//枚举对象实现抽象方法
            return "蓝色";
        }
    };
    public abstract String getColor();//定义抽象方法
}


public class Example{
    public static void main(String[] args) {
        for (Color c:Color.values()){
            System.out.print(c.getColor() + "、");
        }
    }
}

②枚举算法（Enumeration Algorithm）

1）含义

也称为穷举算法，指的是按照问题本身的性质--暴力枚举地列出该问题所有可能的解，并在逐一列举的过程中，将它们逐一与目标状态进行比较以得出满足问题要求的解。在列举的过程中，既不能遗漏也不能重复。

2）使用条件

枚举的可能性是有限的并可被预估；

枚举必须要有一个解的限制的范围，候选答案的范围在求解前有一个确定的集合

3）解题思路

a.确定枚举对象、枚举范围和判断条件，并判断条件设立的正确性。

b.一 一枚举可能出现的情况 ，并验证是否是问题的解。（问题的解不能遗漏也不能重复！！！）

c.考虑枚举算法的效率

4）例子

力扣204.计数质数-----给定整数 n ，返回 所有小于非负整数 n 的质数的数量

示例 1：

输入：n = 10
输出：4
解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

示例 2：

输入：n = 0
输出：0

示例 3：

输入：n = 1
输出：0

class Solution {
    public int countPrimes(int n) {
        int ans = 0;
        for (int i = 2; i < n; ++i) {
            ans += isPrime(i) ? 1 : 0;
        }
        return ans;
    }

    public boolean isPrime(int x) {
        for (int i = 2; i * i <= x; ++i) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }
}

三.拆数

①定义

从一个多位整数中分离出每一位上的数字

②步骤说明

1)初始化

首先，确定你想要分离的多位整数。

2)循环处理

使用一个循环结构（如whlie或for循环），在每次迭代中：

• 使用模运算（%）获取当前数的个位数字。例如，number % 10会给出number的最后一个数字。

• 对当前数执行整除运算（/）并赋值回原变量，去掉已处理的个位数。例如，number /= 10。

• 存储或处理得到的个位数字，根据需要可以选择不同的数据结构来保存这些数字（如数组、列表或字符串）。

3)继续循环

重复上述过程，直到原数变为0。

③示例

public class SeparateDigits {
    public static void main(String[] args) {
        // 假定的多位整数
        int number = 12345;
        
        // 用于存储每一位数字的字符串
        String digits = "";
        
        // 循环直到number变为0
        while(number != 0) {
            // 获取当前数字的个位（即最低位）
            int digit = number % 10;
            
            // 将该位数字添加到字符串的前面
            digits = digit + digits;
            
            // 去掉已处理的个位数字
            number = number / 10;
        }
        
        // 输出分离出的每一位数字
        System.out.println("分离出的每一位数字组成的字符串: " + digits);
    }
}

四.数据的输入与输出

①数据的输入

1）输入一个字符串

import java.util.Scanner;
import java.util.Scanner.*;
public class Example {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scanner.nextLine();
        System.out.println("您输入的字符串是："+str);
    }
}

2）输入一个整数

import java.util.Scanner;
public class Example {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = scanner.nextInt(); // 读取一个整数
        System.out.println("您输入的整数是：" + num);
    }
}

3）输入一个双精度浮点数

import java.util.Scanner;
public class Example {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个双精度浮点数：");
        double dNum = scanner.nextDouble(); // 读取一个双精度浮点数
        System.out.println("您输入的双精度浮点数是：" + dNum);
    }
}

②数据的输出

1）输出数据且换行

public class Example {
    public static void main(String[] args){
        System.out.println("这是输出的数据"); // 输出并自动换行
        System.out.print("这是输出的数据"); // 输出但不换行
    }
}

2）输出双精度浮点数且指定小数点后的位数；

public class Example {
    public static void main(String[] args){
        double num = 123.456789;
        System.out.printf("保留两位小数: %.2f\n", num); // 输出为：保留两位小数: 123.46
    }
}

五.数组

①定义

     数组是用来存储同一种数据类型多个元素的容器

数据类型：可以是基本类型，也可以是引用类型

容器：比如教室、衣柜、纸箱等，可以存放多个事物

②语法格式

数据类型[] 数组名 = new 数据类型[长度];（new为创建数组的关键字，通过new开辟内存空间）

例子：int arr = new int[3];
    
数据类型[] 数据名 = new 数据类型[]{元素1,元素2,元素3...}
（好处：定义时元素是确定的,避免内存空间的浪费）
    
数据类型[] 数组名 = {元素1,元素2,元素3}
（格式三是格式二的变形，简化了代码编写）

③实际操作

1）从键盘上输入多个数据并存储到数组中；

import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 首先询问用户想要输入多少个数字
        System.out.println("请输入您想要输入的整数数量：");
        int n = scanner.nextInt(); // 读取用户指定的数组长度

        // 根据用户输入的数量创建数组
        int[] numbers = new int[n];

        // 使用循环读取每个整数并存储到数组中
        for (int i = 0; i < n; i++) {
            System.out.println("请输入第 " + (i+1) + " 个整数：");
            numbers[i] = scanner.nextInt(); // 读取整数并存储到数组
        }

        // 显示用户输入的数组内容
        System.out.println("您输入的整数数组为：");
        for (int num : numbers) {
            System.out.print(num + " ");
        }

        scanner.close(); // 关闭scanner对象以避免资源泄露
    }
}

2）遍历数组及搜索数组中符合某种特征的元素；

遍历数组遍历数组通常使用for循环或者增强型for循环（for each）来完成。

//传统for循环
int[] array = {1, 2, 3, 4, 5};
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

//增强型for循环
int[] array = {1, 2, 3, 4, 5};
for (int element : array) {
    System.out.println(element);
}

搜索数组中符合某种特征的元素,可以在遍历的过程中添加条件判断。

int[] numbers = {1, 2, 3, 4, 5, 6};
System.out.println("偶数有：");
for (int num : numbers) {
    // 判断当前元素是否为偶数
    if (num % 2 == 0) {
        System.out.println(num);
    }
}

3)具体案例

假设我们有一个整数数组，里面包含了正数、负数和零。我们的任务是遍历这个数组，找出并打印出所有正数的值。

public class Example {
    public static void main(String[] args) {
        // 定义一个包含正数、负数和零的整数数组
        int[] numbers = {-5, 3, 0, 7, -2, 11, 4};

        // 打印提示信息
        System.out.println("正数有：");

        // 遍历数组
        for (int num : numbers) {
            // 判断当前元素是否为正数
            if (num > 0) {
                // 打印正数
                System.out.print(num+" ");
            }
        }
    }
}

六.类与对象

①类的基础知识

1）定义

类是组成Java程序的基本要素，一个Java应用程序是由若干类组成的

2）命名规则

类的名字要符合标识符的规定，即名字可以由名字、下划线、数字或美元符号组成，并且第一个字符不能是数字

（注意：如果类名使用拉丁字母，那么名字的首字母使用大写字母）

3）类的声明

类通常包含属性（成员变量）和方法（成员函数）。

public class MyClass {
    // 属性定义
    private String name;
    private int age;

    // 构造方法定义
    public MyClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法定义
    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;
    }

    // 其他业务方法定义
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    // 重写toString()方法
    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

②定义最终类

要在Java中定义一个不可被继承的最终类，只需在类的声明前加上final关键字。

public final class FinalClass {
    // 类定义...
}

③方法重载

1）定义

一个类中的方法可以有多个方法具有相同的名字，但这些方法的的参数必须不同(即或者是参数的个数不同，或者参数的类型不同)

2）实例

在下面的Area类中，getArea方法是一个重载方法

class Area {
    float getArea(float r) {
        return 3.14f * r * r;
    }

    double getArea(float x, int y) {
        return x * y;
    }

    float getArea(int x, float y) {
        return x*y;
    }
    
    double getArea(float x,float y,float z){
        return (x*x+y*y+z*z)*2.0;
    }
}

注：方法的返回类型与参数的名字不参与比较，也就是说，如果两个方法的名字相同，即使类型不同，也必须保证参数不同

③定义业务方法

1）定义

指的是除了构造方法、getter和setter等基本成员方法之外，用于实现特定业务逻辑或功能的方法。这些方法直接反映了对象能执行的操作或者提供的服务。

2）基本语法

访问修饰符：确定方法的可访问性，如public（公有）、private（私有）、protected（受保护）或默认（包内可见）。

返回类型：方法执行后返回的数据类型，如果没有返回值则使用void。

方法名：应遵循驼峰命名法，描述方法的功能。

参数列表：位于括号内，指定传入方法的参数及其类型。如果没有参数，则留空。

方法体：花括号{}内的代码块，实现了方法的具体功能。

3）实例

假设有一个BankAccount类，除了基本的账户余额管理，我们还希望添加一个转账的方法，这就是一个典型的其他业务方法。

public class BankAccount {
    private double balance; // 账户余额

    // 构造方法、getter和setter省略...

    /**
     * 转账业务方法
     * 
     * @param otherAccount 目标账户
     * @param amount 转账金额
     * @return 成功与否
     */
    public boolean transfer(BankAccount otherAccount, double amount) {
        if (amount <= 0 || amount > this.balance) {
            System.out.println("转账失败：金额无效或余额不足！");
            return false;
        }
        
        // 执行转账操作
        this.balance -= amount;
        otherAccount.deposit(amount); // 假设deposit方法用于存入金额
        
        System.out.println("转账成功！");
        return true;
    }
    
    // 其他业务方法，如查询交易记录、计算利息等可以类似定义
}

④方法重写

1）定义

子类通过重写可以隐藏已继承的实例方法

2）基本条件

1. 继承关系：重写发生在继承关系中，即子类重写父类的方法。

2. 方法签名匹配：子类中的方法名、返回类型、参数列表必须与父类中的被重写方法完全一致。

3. 访问权限不能更严格：子类中重写的方法的访问权限修饰符至少与父类中的方法一样开放。例如，如果父类方法是public的，子类重写的方法不能是private或protected。

4. 例外抛出规则：在Java中，子类重写的方法所抛出的异常类型不能比父类方法声明的异常更宽泛（例外是在Java 7及以后，子类方法可以抛出未检查异常，无论父类方法是否抛出异常）。

3）重要性

• 多态性：通过方法重写，可以实现多态性，即同一个方法调用可以根据对象的实际类型表现出不同的行为。

• 代码复用与扩展性：子类可以复用父类的接口和方法定义，同时根据自身需求修改方法的具体实现，增强了代码的灵活性和可扩展性。

• 提升代码可读性和维护性：合理地使用方法重写可以让代码结构更加清晰，便于理解和维护。

4）示例

如何重写toString()方法

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

    // 构造方法、getter和setter省略...

    /**
     * 重写toString方法，返回表示Person对象的字符串
     * 
     * @return 该Person对象的字符串表示形式
     */
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

⑤对象

1）构造方法

a.默认的构造方法(无参数的，且在方法体中没有语句)

class Person{
    int x,y;
}

b.自定义构造方法（类中定义了一个或者多个构造方法）

class Person{
    int x,y;
    
    public Point(){
        x=1;
        y=1;
    }
    
     public Point(int a,int b){
        x=a;
        y=b;
    }
}

(每个类可以有多个构造方法，但它们的参数列表必须不同，这就是构造方法重载。)

2)创建对象

a.使用无参构造方法创建对象

Person person1 = new Person();

b.使用带有参数的构造方法创建对象

//这里，person2的名字被初始化为"Alice"，年龄为30。
Person person2 = new Person("Alice", 30);

3)调用对象的方法

public class Example {
    String name;
    int age;

    //构造函数
    public Example(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 添加一个介绍自己的方法
    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }

    public static void main(String[] args){
        Example example1 = new Example("Bod",25);
        example1.introduce();
    }
}

七.抽象类

①理解

1）抽象类可以抽象出重要的行为标准，该行为标准用抽象方法来表示。

（即抽象类封装了子类必须有的行为标准）

2）抽象类声明的对象可以成为其子类的对象的上转型对象，调用子类重写的方法。

（即体现子类根据抽象类里的行为标准给出具体的行为）

②特点

1）abstract类中可以有abstract方法

2）abstract类不能用new运算符创建对象，说明抽象类必须被继承，才能被使用。

3）一个非abstract类是abstract类的子类，它必须重写父类的abstract方法

4）abstract类的对象作为上转型对象

（上转型对象：父类类型的引用可以指向子类的对象，但只能访问那些在父类中定义的成员变量和方法。）

③定义

1）抽象类和抽象方法的定义

abstract class ClassName {
    // 抽象方法声明
    abstract returnType methodName(parameterList);

    // 可以有非抽象方法
    nonAbstractMethod() {
        // 方法实现
    }
}

2）创建子类

如果你创建的子类不是抽象的，那么你必须实现所有继承来的抽象方法。如果子类保持为抽象类，那么它不需要实现所有抽象方法，但可以添加更多抽象方法。

class SubclassName extends AbstractClassName {
    // 实现抽象方法
    @Override
    returnType methodName(parameterList) {
        // 方法实现
    }
    
    // 子类可以有其他方法和属性
}

3）子类中重写抽象方法

在子类中重写抽象方法，你需要按照方法签名（方法名、参数列表）精确地实现抽象类中的抽象方法。通常，你会使用@Override注解来指示你正在重写父类的方法，尽管这不是强制性的，但这是一个好的实践，因为它可以让你的代码更易于理解和维护。

class ConcreteSubclass extends AbstractClass {
    // 使用@Override注解明确指出这是对父类抽象方法的重写
    @Override
    void someAbstractMethod() {
        // 实现抽象方法的具体逻辑
    }
}

小结：定义抽象类和抽象方法是为了提供一个基础结构，强制子类遵循一定的规则或实现特定的行为。子类通过实现这些抽象方法来完成具体的功能，同时也可以添加自己的特性和方法，体现了面向对象编程中的多态性和继承性。

八.接口

①接口的定义与使用

1）定义

使用 interface 关键字：接口以关键字 interface 开始，后跟接口名。

声明抽象方法：在接口中声明的方法默认是公共的（虽然 public 关键字可以省略）和抽象的（即使 abstract 关键字也不需要写），因此它们不需要提供方法体。

常量定义：接口还可以包含静态常量，这些常量在定义时必须初始化。

2）使用

default的实例方法：访问权限一定是public（允许省略public）

static方法：访问权限一定是public（允许省略public，final，static修饰符，因为接口中不会有变量）

public interface Animal {
    void eat(); // 抽象方法
    void sleep(); // 另一个抽象方法
    int LEG_COUNT = 4; // 接口中的常量，默认为public static final
    public default int max(int a,int b){
        return a>b?a:b;
    }//default方法（default不可省略）
}

②创建接口实现类

1. 使用 implements 关键字：要实现一个接口，你需要在类的定义中使用 implements 关键字，并列出要实现的接口名称。

2. 实现接口方法：在类中，你需要为接口中声明的所有方法提供具体的实现。

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}

特别需要注意的是：

1）类实现某接口，但类不拥有接口的static方法.

2）接口中方法的访问权限都是public，重写时不可省略public

实现接口的非abstract类一定要重写接口的abstract方法，因此这个类也实现了接口

③在实现类中实现接口方法

• 使用 @Override 注解可放在实现方法之前，这不是强制性的，但这是一个好的实践，因为它可以帮助编译器检查你是否正确地重写了方法。

• 确保实现类提供了接口中所有抽象方法的具体实现。否则，该类也必须被声明为抽象的。

九.List

①List接口的定义

实现了List接口的对象又称为List集合，List集合中存放的对象是有序的，可以重复。有序是指元素的存入顺与取出顺序是一致的。List集合中的元素线性排列，可以通过索引来访问集合中的元素。

1. ArrayList：基于动态数组实现，支持随机访问。

2. LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

3. Vector：和 ArrayList 类似，但它是线程安全的。

   • Stack：它实现了一个标准的后进先出的栈，是 Vector 的子类。

4. CopyOnWriteArrayList：一个线程安全的 ArrayList

②List 的使用

1）创建List对象

1. 使用ArrayList作为实现类:

   List<String> myList = new ArrayList<String>();

2. 使用泛型推断简化语法 (Java 7及以上版本):

   List<String> myList = new ArrayList<>();

3. 使用LinkedList作为实现类:

   List<String> myList = new LinkedList<>();

2）向List中添加新元素

1. 使用add(E element)方法 在列表末尾添加元素:

   myList.add("Element");

2. 使用add(int index, E element)方法 在指定位置插入元素:

   myList.add(0, "FirstElement"); // 在列表开头插入

3. 使用addAll(Collection<? extends E> c)方法 添加一个集合中的所有元素到列表末尾:

   List<String> anotherList = Arrays.asList("A", "B");
   myList.addAll(anotherList);

3）修改List中的元素

直接通过索引来修改已存在的元素：

myList.set(0, "NewElement"); // 将索引为0的元素替换为"NewElement"

1)-3)的具体实现：

import java.util.ArrayList;
import java.util.List;

public class Example {
    public static void main(String[] args){
        // 创建ArrayList类型的List
        List<String> namesList = new ArrayList<>();

        // 向List中添加元素
        namesList.add("Alice");
        namesList.add("Bob");
        namesList.add("Charlie");

        System.out.println("初始List: " + namesList);

        // 修改List中的元素
        namesList.set(1, "Bobby"); // 将索引为1的元素"Bob"改为"Bobby"
        System.out.println("修改后的List: " + namesList);
    }
}

4）迭代器遍历List

迭代器：Iterator 对象有两个方法：boolean hasNext() 判断是否有下一个元素，E next() 返回下一个元素。因此，使用 Iterator 遍历 List 代码如下：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Example {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "pear", "banana");
        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

5）使用for及for-each语句遍历List。

for循环：和数组类型，我们要遍历一个 List，完全可以用 for 循环根据索引配合 get(int) 方法遍历：

import java.util.Arrays;
import java.util.List;

public class Example {
    public static void main(String[] args) {
        List<String> list =  Arrays.asList("apple", "pear", "banana");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

加强版 for 循环：Java 的 for each 循环就可以帮我们使用 Iterator 遍历。把上面的代码再改写如下：

import java.util.Arrays;
import java.util.List;

public class Example {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "pear", "banana");
        for (String s : list) {
            System.out.println(s);
        }
    }
}