/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description: 测试类
 * @Version: 1.0
 */
public class Demo {
    /**
     * aFun方法调用bFun方法
     */
    public static void aFun() {
        bFun();
    }
    /**
     * bFun方法一定会抛出异常
     */
    public static void bFun(){
        throw new RuntimeException("这里一定会抛出一个运行时异常");
    }
    public static void main(String[] args) {
        // main方法调用aFun方法
        aFun();
    }
}

/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description: 测试类
 * @Version: 1.0
 */
public class Demo {
    /**
     * 获取 Logger 实例
     */
    private static final Logger logger = Logger.getLogger(Demo.class.getName());
    public static void main(String[] args) {
        try {
            // 可能会引发空指针异常的代码
            String str = null;
            System.out.println(str.length());
        } catch (NullPointerException e) {
            // 异常处理代码，使用 log.error 记录异常信息
            logger.log(Level.SEVERE, "发生空指针异常", e);
            // 不建议使用System.out.println，因为它无法看出是哪个类的日志
            // System.out.println("发生空指针异常");
            // 不建议使用e.printStackTrace()，因为它会打印到控制台，不符合日志规范
            // e.printStackTrace();
        } finally {
            // 无论是否发生异常都会执行的代码
            System.out.println("这一行一定会执行");
        }
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    /**
     * 逆序打印正整数
     * @param i
     */
    public static void printNumber(int i){
        if(i==0){
            return;
        }
        // 下面错误的把i-1，写成i，会导致无限递归
        // printNumber(i-1);
        printNumber(i);
    }
    public static void main(String[] args)  {
        // 打印100,99...,1
        printNumber(100);
    }
}

/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description: 测试类
 * @Version: 1.0
 */
public class Demo {
    /**
     * throws可能会抛出异常
     * @throws Exception 抛出异常
     */
    public void possibleException() throws Exception {
        // 可能会引发空指针异常的代码
    }
    /**
     * throw一定会抛出指定的异常
     */
    public void throwException(){
        throw new RuntimeException("这里一定会抛出一个运行时异常");
    }
}

try{
   // 可能会引发空指针异常的代码
}catch(Exception e){
   // 异常处理代码
}

try{
   // 可能会引发空指针异常的代码
}catch(Exception e){
   // 异常处理代码
}finally{    
    // 只要程序不崩溃，不管catch里有没有捕获到异常，finally块中的代码都会在最后执行
}

public static void main(String[] args) throws ParseException {
        // 测试数组越界异常
        int[] arr = {1, 2, 3};
        try {
            // 访问越界的数组元素
            System.out.println(arr[10]);
            // 捕获数组越界异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获数组下标越界异常"+e);
        }
        System.out.println("异常被捕获、处理后，程序将不再被终止，而是继续执行");
    }

/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description: 自定义异常类
 * @Version: 1.0
 */
public class ScoreException extends Exception {
    public ScoreException(String wrongScore) {
        //带参构造，异常时控制台输出指定字符串
        super(wrongScore);
    }
}

/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description: 学生类
 * @Version: 1.0
 */
public class Student {
    /**
     * 检查分数是否合法
     * @param score 分数
     * @throws ScoreException：要加throws，声明此方法会抛出异常
     */
    public void checkScore(int score) throws ScoreException{
        System.out.println("开始检查分数");
        if(score>100||score<0){
            throw new ScoreException("分数"+score+"不合法");
        }
        else {
            System.out.println("分数正常");
        }
    }
}

/**
 * @Author: vincewm
 * @CreateTime: 2024/05/20
 * @Description:
 * @Version: 1.0
 */
public class Demo {
    public static void main(String[] args) {
        Student s=new Student();
        try{
            s.checkScore(111);
        }catch (ScoreException e){
            e.printStackTrace();
        }
        System.out.println("这里也能输出");
    }
}

List list = Collections.synchronizedList(new ArrayList());

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)     // 如果没有 hash 碰撞，则直接插入
            tab[i] = newNode(hash, key, value, null);
    }

Collections.synchronizedMap(map);

/**
 * @Author: vince
 * @CreateTime: 2024/05/13
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 创建一个集合
        Collection<String> collection = new ArrayList<>();
        // 使用 add() 方法向集合中添加元素
        collection.add("苹果");
        collection.add("香蕉");
        collection.add("樱桃");
        System.out.println("添加元素后: " + collection);
        // 遍历集合
        System.out.println("开始遍历集合...");
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
        System.out.println("遍历集合完毕...");
        // 使用 contains() 方法检查集合中是否包含指定元素
        boolean containsBanana = collection.contains("香蕉");
        System.out.println("包含 '香蕉': " + containsBanana);
        // 使用 size() 方法返回集合中的元素数量
        int size = collection.size();
        System.out.println("集合的大小: " + size);
        // 使用 isEmpty() 方法检查集合是否为空
        boolean isEmpty = collection.isEmpty();
        System.out.println("集合是否为空: " + isEmpty);
        // 使用 remove() 方法从集合中移除一个指定的元素
        collection.remove("香蕉");
        System.out.println("移除 '香蕉' 后: " + collection);
        // 再次使用 size() 方法返回集合中的元素数量
        size = collection.size();
        System.out.println("移除后集合的大小: " + size);
        // 使用 clear() 方法移除集合中的所有元素
        collection.clear();
        System.out.println("清空集合后: " + collection);
        // 使用 isEmpty() 方法检查集合是否为空
        isEmpty = collection.isEmpty();
        System.out.println("清空后集合是否为空: " + isEmpty);
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建一个 HashMap
        Map<Integer, String> map = new HashMap<>();
        // 使用 put() 方法向映射中添加键值对
        map.put(1, "苹果");
        map.put(2, "香蕉");
        map.put(3, "樱桃");
        System.out.println("添加键值对后: " + map);
        // 使用 get() 方法根据键获取对应的值
        String value = map.get(2);
        System.out.println("键 2 对应的值: " + value);
        // 使用 containsKey() 方法检查是否包含指定键
        boolean containsKey2 = map.containsKey(2);
        System.out.println("包含键 2: " + containsKey2);
        // 使用 containsValue() 方法检查是否包含指定值
        boolean containsValueBanana = map.containsValue("香蕉");
        System.out.println("包含值 '香蕉': " + containsValueBanana);
        // 使用 size() 方法返回映射中的键值对数量
        int size = map.size();
        System.out.println("映射的大小: " + size);
        // 使用 isEmpty() 方法检查映射是否为空
        boolean isEmpty = map.isEmpty();
        System.out.println("映射是否为空: " + isEmpty);
        // 使用 remove() 方法根据键移除键值对
        map.remove(2);
        System.out.println("移除键 2 后: " + map);
        // 再次使用 size() 方法返回映射中的键值对数量
        size = map.size();
        System.out.println("移除后映射的大小: " + size);
        // 使用 clear() 方法移除映射中的所有键值对
        map.clear();
        System.out.println("清空映射后: " + map);
        // 使用 isEmpty() 方法检查映射是否为空
        isEmpty = map.isEmpty();
        System.out.println("清空后映射是否为空: " + isEmpty);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsExample {
    public static void main(String[] args) {
        // 创建一个ArrayList并添加元素
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(3);
        list.add(8);
        list.add(1);
        list.add(6);
        // 输出原始列表
        System.out.println("原始列表: " + list);
        // 使用sort方法按自然顺序排序
        Collections.sort(list);
        System.out.println("排序后的列表: " + list);
        // 使用reverse方法反转列表
        Collections.reverse(list);
        System.out.println("反转后的列表: " + list);
        // 使用binarySearch方法查找元素
        int index = Collections.binarySearch(list, 3);
        System.out.println("元素3的索引: " + index);
        // 创建一个目标列表并使用copy方法复制元素
        List<Integer> destList = new ArrayList<>(Collections.nCopies(list.size(), 0));
        Collections.copy(destList, list);
        System.out.println("复制后的目标列表: " + destList);
        // 使用fill方法填充列表
        Collections.fill(list, 7);
        System.out.println("填充后的列表: " + list);
        // 使用swap方法交换元素
        Collections.swap(destList, 0, destList.size() - 1);
        System.out.println("交换后的目标列表: " + destList);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/05/13
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 使用asList方法将数组转换为列表
        String[] stringArray = {"apple", "banana", "cherry"};
        List<String> stringList = Arrays.asList(stringArray);
        System.out.println("数组转换为列表: " + stringList);
        // 使用sort方法对数组进行排序
        int[] intArray = {5, 3, 8, 1, 6};
        System.out.println("原数组（直接打印）: " + intArray);
        System.out.println("原数组（用Arrays.toString()打印）：" + Arrays.toString(intArray));
        Arrays.sort(intArray);
        System.out.println("排序后的数组: " + Arrays.toString(intArray));
        // 使用binarySearch方法查找元素
        int index = Arrays.binarySearch(intArray, 3);
        System.out.println("元素3的索引: " + index);
        // 使用copyOf方法复制数组
        int[] copiedArray = Arrays.copyOf(intArray, intArray.length);
        System.out.println("复制后的数组: " + Arrays.toString(copiedArray));
        // 使用deepEquals方法比较多维数组
        Integer[][] deepArray1 = {
       {1, 2}, {3, 4}};
        Integer[][] deepArray2 = {
       {1, 2}, {3, 4}};
        boolean deepEqual = Arrays.deepEquals(deepArray1, deepArray2);
        System.out.println("多维数组是否深度相等: " + deepEqual);
        // 使用fill方法填充数组
        int[] fillArray = new int[5];
        Arrays.fill(fillArray, 7);
        System.out.println("填充后的数组: " + Arrays.toString(fillArray));
        // 使用toString方法将数组转换为字符串
        String arrayString = Arrays.toString(intArray);
        System.out.println("数组的字符串表示: " + arrayString);
    }
}

public static void main(String[] args) {
        // 创建一个 ArrayList
        ArrayList<Integer> arrayList = new ArrayList<>();
        // 使用 add() 方法向集合中添加元素
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        System.out.println("添加元素后: " + arrayList);
        // 使用 get() 方法获取指定索引的元素
        int elementAtIndex2 = arrayList.get(2);
        System.out.println("索引 2 处的元素: " + elementAtIndex2);
        // 使用 set() 方法修改指定索引的元素
        arrayList.set(2, 35);
        System.out.println("修改索引 2 后: " + arrayList);
        // 使用 remove() 方法移除指定索引的元素
        arrayList.remove(1);
        System.out.println("移除索引 1 后: " + arrayList);
        // 使用 size() 方法获取集合的大小
        int size = arrayList.size();
        System.out.println("集合的大小: " + size);
        // 使用 contains() 方法检查集合中是否包含某个元素
        boolean contains30 = arrayList.contains(30);
        System.out.println("集合中是否包含 30: " + contains30);
        // 使用 isEmpty() 方法检查集合是否为空
        boolean isEmpty = arrayList.isEmpty();
        System.out.println("集合是否为空: " + isEmpty);
    }

transient Object[] elementData; // non-private to simplify nested class access

/**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

// minCapacity 代表着最小扩容量
private void grow(int minCapacity) {
    // elementData 是 ArrayList 存储数据的数组，这里是获取当前数组的长度
    int oldCapacity = elementData.length;
    // 计算扩容后的数组长度 = 当前数组长度 + (当前数组长度 * 0.5)；也就是扩容到当前的 1.5 倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 判断新的数组是否满足最小扩容量，如果不满足就将新数组的扩容长度赋值为最小扩容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果扩容后的长度超过了最大数组大小，则将其设置为合适的容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity 通常接近于 size，因此这是一个有效的优化
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public void trimToSize() {
    // 增加modCount，modCount是ArrayList的属性，用于记录集合被修改的次数。
    // 除了ArrayList，LinkedList、HashSet、TreeSet、HashMap、TreeMap等集合都有modCount属性
    modCount++;
    // 如果当前大小小于数组的长度，则进行缩容操作
    if (size < elementData.length) {
        // 如果 size 为 0，则将 elementData 置为 EMPTY_ELEMENTDATA
        // 否则将 elementData 缩容到 size 大小
        elementData = (size == 0) 
            ? EMPTY_ELEMENTDATA 
            : Arrays.copyOf(elementData, size);
    }
}

public boolean add(E e) {
    // 1.扩容：判断列表的capacity容量是否足够，是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 2.添加：真正将元素放在列表的元素数组里面
    elementData[size++] = e;
    return true;
}

Collections.synchronizedList(new ArrayList<>());

import java.util.ArrayList;
public class ForLoopExample {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用 for 循环遍历
        System.out.println("使用 for 循环遍历:");
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i) + " ");
        }
        System.out.println();
    }
}

// 数据类型：即遍历对象中元素的数据类型。
        // 变量名：遍历时声明的变量，每次遍历得到的元素都会赋值给这个变量。
        // 数组或者集合对象：需要遍历的对象。
        for (数据类型 变量名 : 数组或者Collection集合对象) {
            //循环体
            System.out.println(变量名);
        }

public class EnhancedForLoopExample {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用增强 for 循环遍历
        System.out.println("使用增强 for 循环遍历:");
        for (Integer num : arrayList) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

import java.util.ArrayList;
import java.util.Iterator;
public class IteratorRemoveExample {
    public static void main(String[] args) {
        // 创建一个 ArrayList 并添加一些元素
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 获取 ArrayList 的迭代器
        Iterator<Integer> iterator = arrayList.iterator();
        // 使用迭代器遍历 ArrayList 并移除元素
        System.out.println("使用迭代器遍历 ArrayList 并移除元素:");
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if (num > 30) {
                iterator.remove(); // 移除大于 30 的元素
            }
        }
        // 打印修改后的 ArrayList
        System.out.println("修改后的 ArrayList:");
        for (Integer num : arrayList) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

public class ListIteratorExample {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用 ListIterator 遍历（正向）
        System.out.println("使用 ListIterator 正向遍历:");
        ListIterator<Integer> listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();
        // 使用 ListIterator 反向遍历
        System.out.println("使用 ListIterator 反向遍历:");
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previous() + " ");
        }
        System.out.println();
    }
}

import java.util.ArrayList;
public class ForEachLambdaExample {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用 forEach 方法和 Lambda 表达式遍历
        System.out.println("使用 forEach 方法和 Lambda 表达式遍历:");
        arrayList.forEach(num -> System.out.print(num + " "));
        System.out.println();
    }
}

import java.util.ArrayList;
public class StreamExample {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用 Stream API 遍历
        System.out.println("使用 Stream API 遍历:");
        arrayList.stream().forEach(num -> System.out.print(num + " "));
        System.out.println();
    }
}

public static void main(String[] args) {
        // 创建一个 ArrayList
        List<String> list = new ArrayList<>();
        // 增加元素
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");
        System.out.println("增加元素后：" + list);
        // 在指定索引插入元素
        list.add(1, "元素4");
        System.out.println("在索引1插入元素4后：" + list);
        // 删除指定索引的元素
        list.remove(2);
        System.out.println("删除索引2的元素后：" + list);
        // 修改指定索引的元素
        list.set(1, "元素5");
        System.out.println("修改索引1的元素为元素5后：" + list);
        // 获取指定索引的元素
        String element = list.get(2);
        System.out.println("获取索引2的元素：" + element);
        // 获取元素的索引
        int index = list.indexOf("元素5");
        System.out.println("元素5的索引：" + index);
        // 遍历集合
        System.out.println("使用for循环遍历集合：");
        for (int i = 0; i < list.size(); i++) {
            System.out.println("索引" + i + "的元素：" + list.get(i));
        }
        // 使用 ListIterator 迭代器遍历集合
        System.out.println("使用ListIterator遍历集合：");
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println("元素：" + listIterator.next());
        }
        // 获取子列表
        List<String> subList = list.subList(1, 3);
        System.out.println("子列表（从索引1到索引2）： " + subList);
    }

// 推荐，面向接口编程，多态形式，对象实例指向接口引用
List<Integer> arrayList = new ArrayList<>();
// 不推荐，常规创建对象形式
ArrayList<Integer> arrayList = new ArrayList<>();

List<Integer> list=new LinkedList<>()；

public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<String>();
        link.addLast("hello");
        link.addLast("world");
        for(String s:link) System.out.println(s);
        System.out.println(link);
    }

import java.util.HashSet;
import java.util.LinkedList;
public class Test2 {
    public static void main(String[] args) {
        HashSet<String > h=new HashSet<String>();
        h.add("nihao");
        String s1=new String("nihao");
        h.add(s1);
        System.out.println(s1=="nihao");        //false
        for(String s:h) System.out.println(s);     //不含重复元素 
    }
}

import java.util.HashSet;
public class Test {
    public static void main(String[] args) {    //输出23
        Dog dog1=new Dog(23);
        Dog dog2=new Dog(23);
        HashSet<Dog> h=new HashSet<Dog>();
        h.add(dog1);h.add(dog2);
        for(Dog dog:h) System.out.println(dog.weight);   
    }
}

package package1;
public class Dog extends Animal{
     int weight=4;
     public Dog(){
//         System.out.println("doggouzaao");
     }
     public Dog(int weight){
         this.weight=weight;
     }
    @Override
    public void show() {
        name="dogname";
        System.out.println("dog");
    }
    @Override
    public boolean equals(Object o) {    //alt+insert生成equals()和hashCode()方法。这里其实只需要重写hashCode方法就能保证自动去重，equals方法用于元素间的比较
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return weight == dog.weight;
    }
    @Override
    public int hashCode() {
        return weight;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                '}';
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
//    @Override
    public int hashCode() {
        return 1;
    }
    public static void main(String[] args) {
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description:
 * @Version: 1.0
 */
class Student {
    private String name;
    private int id;
    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }
    /**
     * 重写 hashCode() 方法，返回学号作为哈希值
     * @return int
     */
    @Override
    public int hashCode() {
        return id;
    }
    /**
     * 重写 equals() 方法，判断学号是否相同
     * @param obj
     * @return boolean
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Student student = (Student) obj;
        return id == student.id;
    }
    /**
     * 重写 toString() 方法，返回学生姓名和学号
     * @return {@link String }
     */
    @Override
    public String toString() {
        return "Student{name='" + name + "', id=" + id + "}";
    }
    public static void main(String[] args) {
        Student student1 = new Student("Tom", 1);
        Student student2 = new Student("Tom", 1);
        // 根据重写的 equals() 方法输出
        // true
        System.out.println(student1.equals(student2));
        // 1
        System.out.println(student1.hashCode());
        // 1
        System.out.println(student2.hashCode());
        // 根据重写的 toString() 方法输出
        // Student{name='Tom', id=1}
        System.out.println(student1.toString());
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建一个 HashMap
        Map<String, String> fruitColor = new HashMap<>();
        // 使用 put() 方法向映射中添加键值对
        fruitColor.put("苹果", "红色");
        fruitColor.put("香蕉", "黄色");
        fruitColor.put("樱桃", "红色");
        System.out.println("添加键值对后: " + fruitColor);
        // 使用 get() 方法根据键获取对应的值
        String value = fruitColor.get("香蕉");
        System.out.println("键 '香蕉' 对应的值: " + value);
        // 遍历 keySet
        Set<String> keys = fruitColor.keySet();
        System.out.println("遍历 keySet:");
        for (String key : keys) {
            System.out.println("水果: " + key + " 颜色: " + fruitColor.get(key));
        }
        // 使用 containsKey() 方法检查是否包含指定键
        boolean containsKeyBanana = fruitColor.containsKey("香蕉");
        System.out.println("包含键 '香蕉': " + containsKeyBanana);
        // 使用 containsValue() 方法检查是否包含指定值
        boolean containsValueYellow = fruitColor.containsValue("黄色");
        System.out.println("包含值 '黄色': " + containsValueYellow);
        // 使用 size() 方法返回映射中的键值对数量
        int size = fruitColor.size();
        System.out.println("映射的大小: " + size);
        // 使用 isEmpty() 方法检查映射是否为空
        boolean isEmpty = fruitColor.isEmpty();
        System.out.println("映射是否为空: " + isEmpty);
        // 使用 remove() 方法根据键移除键值对
        fruitColor.remove("香蕉");
        System.out.println("移除键 '香蕉' 后: " + fruitColor);
        // 再次使用 size() 方法返回映射中的键值对数量
        size = fruitColor.size();
        System.out.println("移除后映射的大小: " + size);
        // 使用 clear() 方法移除映射中的所有键值对
        fruitColor.clear();
        System.out.println("清空映射后: " + fruitColor);
        // 使用 isEmpty() 方法检查映射是否为空
        isEmpty = fruitColor.isEmpty();
        System.out.println("清空后映射是否为空: " + isEmpty);
    }
}

Collections.synchronizedMap(map);

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)     // 如果没有 hash 碰撞，则直接插入
            tab[i] = newNode(hash, key, value, null);
    }

/**
 * @Author: vince
 * @CreateTime: 2024/07/02
 * @Description: 狗类：按自然排序时要实现Comperable<>并重写compareTo()方法
 * @Version: 1.0
 */
public class Dog  implements Comparable<Dog>{        
    int weight;
    String name;
    public Dog(int weight, String name) {
        this.weight = weight;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                ", name='" + name + '\'' +
                '}';
    }
    @Override
    public int compareTo(Dog dog){    //实参是上一只狗，本狗与上狗做比较
        //返回正数，即本狗比上只狗大，按存取顺序排序
        return 1;
        //return -1;存储逆序排序
        //return 0;视为相等，后插入的重复元素会被删除。
        //return this.weight-dog.weight;按体重从小到大排序，后狗-前狗。
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 创建两个小狗对象，让他们按自己compareTo()逻辑排序，即按存取顺序排序
        Dog dog1=new Dog(23,"abc");
        Dog dog2=new Dog(45,"abc");
        Dog dog3=new Dog(45,"abc");
        TreeSet<Dog> dogs=new TreeSet<>();
        dogs.add(dog1);dogs.add(dog2);dogs.add(dog3);
        // 因为第三只狗和第二只狗存取顺序不同，所以他们被认为是两只狗
        // [Dog{weight=26, name='abc'}, Dog{weight=26, name='abcd'}, Dog{weight=34, name='abc'}]
        System.out.println(dogs);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/02
 * @Description: 狗类：按比较器排序时不需要再实现Comperable<>
 * @Version: 1.0
 */
public class Dog {
    int weight;
    String name;
    
    public Dog(int weight, String name) {
        this.weight = weight;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                ", name='" + name + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Dog dog = (Dog) o;
        return weight == dog.weight && Objects.equals(name, dog.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(weight, name);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        //下面比较器也可以用Lambda表达式形式，即TreeSet<>((a,b)->{..})
        TreeSet<Dog> dogs=new TreeSet<>(new Comparator<Dog>() {
            @Override
            public int compare(Dog a, Dog b){
                if(a.weight!=b.weight) {
                    return a.weight-b.weight;
                }
                else {
                    return a.name.compareTo(b.name);
                }
            }
        });
        dogs.add(new Dog(34,"abc"));
        dogs.add(new Dog(26,"abc"));
        dogs.add(new Dog(26,"abcd"));
        dogs.add(new Dog(26,"abcd"));
        // 可以看见，前三只狗按体重、名称排序，第四只狗被去重了
        // [Dog{weight=26, name='abc'}, Dog{weight=26, name='abcd'}, Dog{weight=34, name='abc'}]
        System.out.println(dogs);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: ArrayList<E>是标准的类泛型，在使用时指定这个“E”具体是什么
 * @Version: 1.0
 */
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
..
}

// 我们在使用ArrayList时，尖括号指定<String>，这样它就只能存String类型的元素了
ArrayList<String> list = new ArrayList<String>();

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 类泛型
 * @Version: 1.0
 */
class ClassName<T> {
    // 成员变量、构造方法和方法可以使用类型参数T
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/04
 * @Description: ArrayList简化版
 * @Version: 1.0
 */
public class MyList<E> {
    // 初始容量
    private static final int INITIAL_CAPACITY = 10;
    // 存储元素的数组
    private Object[] elementData;
    // 当前元素数量
    private int size;
    // 构造方法，初始化数组和大小
    public MyList() {
        elementData = new Object[INITIAL_CAPACITY];
        size = 0;
    }
    /**
     * 添加元素到列表中
     * @param e
     * @return boolean
     */
    public boolean add(E e) {
        // 如果当前数组容量不足，则扩容
        if (size == elementData.length) {
            grow();
        }
        // 将元素添加到数组中，并增加元素数量
        elementData[size++] = e;
        return true;
    }
    /**
     * 获取指定位置的元素
     * @param index
     * @return {@link E }
     */
    @SuppressWarnings("unchecked")
    public E get(int index) {
        // 检查索引是否有效
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        // 返回元素，强制转换为泛型类型
        return (E) elementData[index];
    }
    /**
     * 返回当前元素数量
     * @return int
     */
    public int size() {
        return size;
    }
    /**
     * 扩容方法，将数组容量扩大 1.5 倍
     */
    private void grow() {
        int newCapacity = elementData.length + (elementData.length >> 1);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    public static void main(String[] args) {
        MyList<String> myList = new MyList<>();
        myList.add("Hello");
        myList.add("World");
        myList.add("!");
        System.out.println("元素数量: " + myList.size());
        // 输出: 第一个元素: Hello
        System.out.println("第一个元素: " + myList.get(0));
        // 输出: 第二个元素: World
        System.out.println("第二个元素: " + myList.get(1));
        // 输出: 第三个元素: !
        System.out.println("第三个元素: " + myList.get(2));
        // 尝试获取索引越界的元素，抛出 IndexOutOfBoundsException
        // System.out.println(myList.get(3));
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 接口泛型
 * @Version: 1.0
 */
interface InterfaceName<T> {
    // 接口中的方法可以使用类型参数T
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/04
 * @Description: 泛型接口
 * @Version: 1.0
 */
public interface IGen<E> {
    public void fun(E e);
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/04
 * @Description: 泛型接口实现类必须指定具体类型，否则会报错
 * @Version: 1.0
 */
public class Gen implements IGen<Integer>{
    @Override
    public void fun(Integer integer) {
        System.out.println(integer);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/04
 * @Description: 泛型接口实现类：如果接口省略<>，则默认是Object
 * @Version: 1.0
 */
public class Gen implements IGen{
    /**
     * 如果参数不是Object，就报错。因为接口了省略<>，默认是IGen<Object>
     * @param integer
     */
    @Override
    public void fun(Object integer) {
        System.out.println(integer);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/07/04
 * @Description: 泛型接口实现类也是泛型类时，泛型参数类型必须与泛型接口保持一致，用<E>，而不是<T>等
 * @Version: 1.0
 */
public class Gen<E> implements IGen<E>{
    @Override
    public void fun(E e) {
        System.out.println(e);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 方法泛型
 * @Version: 1.0
 */
public <T> 返回类型 方法名(参数类型 parameter) {
    // 方法体
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    /**
     * 泛型方法1：返回值和参数可以T
     * @param t
     * @return {@link T }
     */
    public <T> T fun1(T t){
        return t;
    }
    /**
     * 泛型方法1：参数可以是多个，但类型必须都是T
     *
     * @param a
     * @param b
     * @return {@link T }
     */
    public <T> T fun2(T a,T b){
        return a;
    }
    /**
     * 泛型方法2：返回值和参数并不一定是T，也可以是具体类型
     * @param integer
     * @return {@link Integer }
     */
    public <T> void fun3(Integer integer){
        System.out.println(integer);
    }
    public static void main(String[] args) {
        Test test = new Test();
        // 实参传入String类型
        System.out.println(test.fun1("Hello"));
        // 实参传入int类型
        System.out.println(test.fun1(1111));
        // 实参传入多个String类型
        System.out.println(test.fun2("Hello", "World"));
        test.fun3(2222);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();
        strings.add("he");
        integers.add(23);
        // 1.无界通配符用作形参，实参可以是任意元素
        // 打印集合：List<?>可以接受所有List元素类型的实参
        printList(strings);
        printList(integers);
        List<?> anyList=new ArrayList<>();
        // 正确，因为无限定通配符可以写null类型的值。
        anyList.add(null);
        // 下面代码会报错，因为无限定通配符只能读Object类型的值，只能写null类型的值，其他类型都不能读写。
        // anyList.add(23);
    }
    /**
     * * 打印集合：List<?>可以接受所有List元素类型的实参。Collection<?>可以接受任何类型任何元素类型的集合
     * @param c 集合元素
     */
    public static void printList(List<?> c) {
        for (Object e : c) {
            System.out.println(e);
        }
    }
}

public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();
        strings.add("he");
        integers.add(23);
        // 上界通配符可以接受继承于T的类，即T的子类
        printNumbers(integers);
        // 下面会报错，因为上界通配符，元素类型只能是Number的子类
        // printNumbers(strings);
    }
    /**
     * 上界通配符可以接受继承于T的类，即T的子类
     * @param list
     */
    public static void printNumbers(List<? extends Number> list) {
        list.get(0);
        // 下面会报错，因为上界类型通配符只允许读值，不允许写null以外值。
        for (Number number : list) {
            System.out.println(number);
        }
    }

public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();
        strings.add("he");
        integers.add(23);
        addNumbers(integers);
        printList(integers);
        // 下面会报错，因为上界通配符，元素类型只能是Number的子类
        // printNumbers(strings);
    }
    /**
     * * 下界通配符可以接受实现了Integer接口的类，即Integer的父类
     * @param list
     */
    public static void addNumbers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
        // 正确。因为下界类型通配符允许写值
        Object object=list.get(0);
        // 下面会报错，因为下界类型通配符只允许写值，不允许读Object以外类型的值。
        // Number number=list.get(0);
    }

ArrayList<Integer> arrayList = new ArrayList<>();
// 向上转型为 List<Integer>
List<Integer> list = arrayList;

ArrayList<Integer> integerList = new ArrayList<>();
// 编译错误：不能将 ArrayList<Integer> 向上转型为 ArrayList<Number>
// ArrayList<Number> numberList = integerList;

List<Integer> list = new ArrayList<>();
ArrayList<Integer> arrayList = (ArrayList<Integer>) list;  // 向下转型为 ArrayList<Integer>

// 匿名内部类形式
        TreeSet<Dog> dogs = new TreeSet<>(new Comparator<Dog>() {
            @Override
            public int compare(Dog a, Dog b) {
                return a.weight - b.weight;
            }
        });

// Lambda表达式形式
TreeSet<Dog> dogs = new TreeSet<>((a, b) -> a.weight - b.weight);

(参数列表) -> 单个表达式
或
(参数列表) -> { 表达式1;表达式2; }

public class Demo {
    public static void main(String[] args) {
        // 使用Lambda表达式前，需要再创建一个Dog实现类，然后创建对象传入fun()方法
        // 使用Lambda表达式后，直接一行代码就解决了，Lambda表达式本身是实现了add()方法逻辑的Dog对象
        // Lambda形参类型、返回类型可以省略
        fun((a,b)->a+b);
    }
    public static void fun(Dog d){
        d.add(1,4);
    }
}
/**
 * @Author: vince
 * @CreateTime: 2024/06/13
 * @Description: 单方法接口
 * @Version: 1.0
 */
public interface Dog {
    /**
     * 只能有一个方法
     * @param a
     * @param b
     * @return int
     */
    public int add(int a,int b);
}

/**
 * @Author: vince
 * @CreateTime: 2024/05/13
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        // 使用 Stream API 给每个元素加 2 并生成新的列表
        System.out.println("使用 Stream API 遍历并修改元素:");
        List<Integer> modifiedList = arrayList.stream()
                .map(num -> num + 2).sorted().filter(num -> num > 20)
                .collect(Collectors.toList());
        // 打印修改后的列表
        System.out.println(modifiedList);
    }
}

/**
 * 示例代码展示如何生成 Stream 流
 */
public class StreamGeneration {
    public static void main(String[] args) {
        // Collection 体系：可以便用默认方法 stream() 生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();
        // Map 体系：间接的生成流
        Map<String, Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
        // 数组体系：可以通过 Stream 接口的静态方法 of(T... values) 生成流
        String[] strArray = {"hello", "world", "java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

List<String> list = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// forEach 终结后，原 list 不变，处理后的 list 遍历输出
list.stream().filter(item -> !item.isEmpty()).forEach(System.out::println);

List<String> list = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        // 需求: 跳过 2 个元素，把剩下的元素中前 2 个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);

Stream<String> s1 = Stream.of("a", "b", "c");
Stream<String> s2 = Stream.of("b", "c", "d");
Stream.concat(s1, s2).distinct().forEach(System.out::println);

List<String> list = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        // 按字母序排序（默认）
        // forEach 终结后，原 list 不变，处理后的 list 遍历输出
        list = list.stream().sorted((item1, item2) -> {
                    return item1.compareTo(item2);
                }
        ).collect(Collectors.toList());
        System.out.println(list);

List<String> list = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// collect 收集后原 list 不变，处理后的 list 收集成返回值
list = list.stream().map(item -> item.toUpperCase()).collect(Collectors.toList());
System.out.println(list);

List<String> list = Arrays.asList("10", "20", "30");
        // 输出每个元素
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        // 计算元素的总和
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);

List<String> list = Arrays.asList("10", "20", "30");
long count = list.stream().mapToInt(Integer::parseInt).count();
System.out.println(count); // 输出 3

List<String> list = Arrays.asList("10", "20", "30");
list.stream().mapToInt(Integer::parseInt).forEach(value -> System.out.println(value));

List<String> list = new ArrayList<>();
        list.add("123");
        list.add("4567");
        // 1.过滤只保留长度为3的字符串，收集成List<String>类型
        List<String> ansList = list.stream().filter(item -> item.length() == 3).collect(Collectors.toList());
        System.out.println(ansList);
        // 2.收集成List<Integer>类型
        List<Integer> ansList1 = list.stream().map(Integer::parseInt).collect(Collectors.toList());
        System.out.println(ansList1);
        // 3.收集成Set<Integer>类型
        Set<Integer> ansList2 = list.stream().map(Integer::parseInt).collect(Collectors.toSet());
        System.out.println(ansList2);
        // 4.收集成Map<String,Integer>类型,key是字符串，value是长度
        Map<String, Integer> stringSizeMap = list.stream().collect(Collectors.toMap(item -> item, item -> item.length()));
        System.out.println(stringSizeMap);
        // 5.收集成String类型，按逗号分割
        String ansString = list.stream().collect(Collectors.joining(","));
        System.out.println(ansString);

public class Test {
    public static void main(String[] args) {
        // 定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};
        // 获取数组中的最大值
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i : arr) {
                if (i > max) {
                    max = i;
                }
            }
            return max;
        });
        // 输出最大值
        System.out.println("数组中的最大值是: " + maxValue);
    }
    /**
     * 返回一个int数组中的最大值
     *
     * @param sup Supplier<Integer>函数式接口
     * @return int数组中的最大值
     */
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

public class Test {
    public static void main(String[] args) {
        String name = "Hello World";
        // 使用两种方式消费字符串
        operatorString(name, str -> System.out.println("转大写："+str.toUpperCase()), str -> System.out.println("转小写："+str.toLowerCase()));
        // 使用一个方式消费字符串
        operatorString(name, str -> System.out.println("空格替换成下划线："+str.replace(" ", "_")));
    }
    /**
     * 定义一个方法，用两种方式消费同一个字符串数据，共消费5次
     * @param name 字符串数据
     * @param con1 第一个消费者
     * @param con2 第二个消费者
     */
    private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
        // 第一个消费者消费一次
        System.out.println("第一个消费者消费一次");
        con1.accept(name);
        // 第二个消费者消费一次
        System.out.println("第二个消费者消费一次");
        con2.accept(name);
        // 第一个消费者组合第二个消费者，再组合第一个消费者，按顺序各消费一次
        System.out.println("第一个消费者组合第二个消费者，再组合第一个消费者，按顺序各消费一次");
        con1.andThen(con2).andThen(con1).accept(name);
    }
    /**
     * 定义一个方法，消费一个字符串
     * @param name 字符串数据
     * @param con 消费者
     */
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
}

public class Test {
    public static void main(String[] args) {
        // 测试字符串长度是否在5到100之间
        // false
        boolean result = checkString("hello",
                s -> s.length() > 5,
                s -> s.length() < 100);
        System.out.println(result);
        // 测试字符串是否长度不等于5
        // false
        System.out.println(negateCheck("hello",s->s.length()==5));
    }
    /**
     * 检查字符串是否满足两个谓词的逻辑与条件
     * @param s 要检查的字符串
     * @param p1 第一个谓词
     * @param p2 第二个谓词
     * @return 如果字符串满足两个谓词的逻辑与条件，返回true；否则返回false
     */
    private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
        return p1.and(p2).test(s);
    }
    /**
     * 检查字符串是否不满足谓词条件
     * @param s 要检查的字符串
     * @param p 谓词
     * @return 如果字符串不满足谓词条件，返回true；否则返回false
     */
    private static boolean negateCheck(String s, Predicate<String> p) {
        return p.negate().test(s);
    }
}

引用类::不带括号的方法名

/**
 * @Author: vince
 * @CreateTime: 2024/07/02
 * @Description: 狗类：按比较器排序时不需要再实现Comperable<>
 * @Version: 1.0
 */
public class Dog {
    int weight;
    String name;
    public Dog(int weight, String name) {
        this.weight = weight;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "weight=" + weight +
                ", name='" + name + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Dog dog = (Dog) o;
        return weight == dog.weight && Objects.equals(name, dog.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(weight, name);
    }
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 使用Lambda表达式
        TreeSet<Dog> dogsLambda = new TreeSet<>((a, b) -> a.weight - b.weight);
        // 1.使用方法引用，引用compareDogsByWeight()方法
        TreeSet<Dog> dogsMethodRef = new TreeSet<>(Test::compareDogsByWeight);
        // 添加一些示例数据
        dogsLambda.add(new Dog(10, "旺财"));
        dogsLambda.add(new Dog(5, "小黑"));
        dogsLambda.add(new Dog(15, "小白"));
        dogsMethodRef.add(new Dog(10, "旺财"));
        dogsMethodRef.add(new Dog(5, "小黑"));
        dogsMethodRef.add(new Dog(15, "小白"));
        // 打印排序结果
        System.out.println("使用Lambda表达式打印结果:");
        dogsLambda.forEach(dog->{
            System.out.println(dog);
        });
        System.out.println("2.使用方法引用，引用PrintStream类的println方法:");
        dogsMethodRef.forEach(System.out::println);
    }
    /**
     * 比较两个Dog对象的体重
     * @param a 第一个Dog对象
     * @param b 第二个Dog对象
     * @return 返回体重差
     */
    public static int compareDogsByWeight(Dog a, Dog b) {
        return a.weight - b.weight;
    }
}

类名::new

/**
 * Student 类
 */
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

/**
 * StudentBuilder 接口
 */
@FunctionalInterface
interface StudentBuilder {
    Student build(String name, int age);
}

/**
 * @Author: vince
 * @CreateTime: 2024/06/27
 * @Description: 测试类
 * @Version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 使用 Lambda 表达式
        builderLinQinXia((name, age) -> new Student(name, age));
        builderZhangXueYou((name, age) -> new Student(name, age));
        // 使用构造方法引用
        builderLinQinXia(Student::new);
        builderZhangXueYou(Student::new);
    }
    /**
     * 使用 StudentBuilder 创建 Student 对象，对象的name是林青霞
     * @param sb StudentBuilder 接口的实例
     */
    private static void builderLinQinXia(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + " " + s.getAge());
    }
    /**
     * 使用 StudentBuilder 创建 Student 对象，对象的name是张学友
     * @param sb StudentBuilder 接口的实例
     */
    private static void builderZhangXueYou(StudentBuilder sb) {
        Student s = sb.build("张学友", 26);
        System.out.println(s.getName() + " " + s.getAge());
    }
}