// Object.java 类
public boolean equals(Object obj) {
    return (this == obj);
}

// String.java 类
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- = 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

✅ 被 final 修饰的变量、方法、类会被当做常量处理
	🔹 修饰变量
			▪ 修饰基本数据类型： 数据不可变
			▪ 修饰引用数据类型： 地址不可变 （内容可变）
	🔹 修饰方法： 不可以重写
	🔹 修饰类： 不可以继承

✅ ( 选记，理解不了建议不记 ) 在 Java 内存模型中，final 的语义如下：
		▪ 构造函数内对⼀个 final 域的写⼊，与随后把这个被构造对象的引⽤赋值给⼀个引⽤变量，这两个操作之间不能重排序。（JVM 禁⽌编译器把 final 域的写重排序到构造函数之外）
		▪ 初次读⼀个包含 final 域的对象的引⽤，与随后初次读这个 final 域，这两个操作之间不能重排序

✅ 好处：
		▪ 防止它们被改变，安全
		▪ 继承时，保持它们的不变性（针对方法和变量）
		▪ 可读性好，规范
		▪ （ 增加 ）final 变量在编译时被转换成常量，这可以提高程序的性能。

/* String 底层源码 */
private final char value[]; 

/**
* AbstractStringBuilder.java 抽象类
* The value is used for character storage.
*/
char[] value;

Java 中的集合是指一组相关数据类型的对象的容器。Java 提供了许多集合类，可以根据实际情况选择适合的集合类来使用。

常用的 Java 集合包括：
	▪ List：有序可重复的集合，例如 ArrayList、LinkedList
	▪ Set：无序不可重复的集合，例如 HashSet、TreeSet
	▪ Map：具有映射关系的键值对集合，例如 HashMap、TreeMap
	▪ Queue：队列集合，例如 LinkedList、PriorityQueue

另外还有一些特殊的集合类，例如 Stack（栈）、Vector（向量）

除了以上的标准集合类，Java 还提供了一些扩展集合类，例如 ConcurrentHashMap、CopyOnWriteArrayList 等，它们是线程安全的集合类，适合在多线程环境下使用。

在使用集合类时，需要根据实际需求选择适合的集合类，不同的集合类有不同的优劣点。

🆙 在使用集合类时，还需要注意集合类的 并发性、可扩展性、性能 等问题。

int[] a = new int[4];  // 推荐使用 int[] 方式初始化

int c[] = {1, 2, 3, 4};  // 长度：4，索引范围：[0,3]

以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。

ArrayList 底层使用的是 Object 数组，在无参构造函数中默认初始化长度为 10，当需要扩容时会将原数组中的元素重新拷贝到长度为原数组的 1.5 倍的新数组中，扩容代价比较高；

✅️ JDK 7
1. 生成新数组【原数组大小 2 倍】
2. 遍历老数组中的每个位置上的 链表上的每个元素
3. 取每个元素的 key，并基于新数组长度，计算出每个元素在新数组中的下标
4. 将元素添加到新数组中
5. 所有元素转移完了之后，将新数组赋值给 HashMap 对象的 table 属性

✅️ JDK 8
1. 生成新数组【原数组大小 2 倍】
2. 遍历老数组中的每个位置上的 链表/红黑树
3. If is 链表，则直接将链表中的每个元素重新计算下标，并添加到新数组中
4. If is 红黑树，则先遍历红黑树，先计算出红黑树中每个元素对应在新数组中的下标位置
   ① 统计每个下标位置的元素个数
   ② If 该位置下的元素个数超过 8，则生成一个新的红黑树，并将根节点添加到新数组的对应位置
   ③ If 该位置下的元素个数不超过 8，则生成一个链表，并将链表的头节点添加到新数组的对应位置
5. 所有元素转移完了之后，将新数组赋值给 HashMap 对象的 table 属性

📢 转移 红黑树，新树中红黑树结构可能会变（树的结构，会根据数组大小重新计算）

✅️ JDK 7
🎯 数据结构：
    - ReentrantLock + Segment + HashEntry。
    - 一个 Segment 中包含一个 HashEntry 数组，每个 HashEntry 又是一个链表结构。
🎯 元素查询：
    - 二次 hash。第一次 hash 定位到 Segment，第二次 hash 定位到元素所在链表的头部。
🎯 锁：Segment 分段锁。
    - Segment 继承了 ReentrantLock，锁定操作的 Segment，其他的 Segment 不受影响
    - 并发度为 Segment 个数，可以通过构造函数指定
    - 数组扩容不会影响其他的 Segment。
    - 锁粒度小
🎯 get() 无需加锁，volatile 保证可见性

✅️ JDK 8
🎯 数据结构：
    - synchronized + CAS + Node + 红黑树。
    - Node 的 val 和 next 都用 volatile 修饰，保证可见性。
    - 查找、替换、赋值操作都使用 CAS。
🎯 锁：锁链表的 head 节点，不影响其他元素的读写，锁粒度更细，效率更高，扩容时，阻塞所有的读写操作、并发扩容。
🎯 读操作无锁：
    - Node 中 val 和 next 使用 volatile 修饰，读写线程对该变量互相可见。
    - 数组用 volatile 修饰，保证扩容时被读线程感知。
    
📢 Sychronized 在 JDK 8 中做了优化，锁粒度不如之前重了。
   CAS 是乐观锁机制，比之 Sychronized、ReentrantLock 效率更高。 

✅️ JDK 7
1. ConcurrentHashMap 基于 Segment 分段锁实现
2. 每个 Segment 相对于一个小型的 HashMap
3. 每个 Segment 内部会进行扩容，和 HashMap 的扩容逻辑类似
4. 先生成新的数组，然后转移元素到新数组中
5. 扩容的判断：每个 Segment 内部单独判断，判断是否超过阈值

✅️ JDK 8
1. ConcurrentHashMap 不再基于 Segment 分段锁实现
2. 当某个线程进行 put 时，如果发现 ConcurrentHashMap 正在进行扩容，则该线程一起进行扩容
3. 若发现没有正在进行扩容，则将 key-value 添加到 ConcurrentHashMap 中，然后判断是否超过阈值，超过则进行扩容
4. ConcurrentHashMap 支持多个线程同时扩容
5. 扩容之前，先生成一个新的数组
6. 在转移元素时，先将原数组分组，将每组分给不同的线程来进行元素的转移，每个线程负责一组或多组的元素转移工作

CurrentHashMap 在 HashMap 基础上增加了分段式锁。

扩展
🔻底层数据结构（JDK1.8 之后）
HashMap → 在解决哈希冲突时，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间。
CurrentHashMap → 数组+链表/红黑二叉树

🔻是否线程安全
HashMap → 非线程安全
CurrentHashMap → 线程安全
Hashtable → 线程安全 → 因为 Hashtable 内部的方法基本都经过 synchronized 修饰 Hashtable 基本被淘汰

🔻是否线程安全
HashMap → 可以存储 null 的 key 和 value，但 null 作为键只能有一个，作为值可以有多个
CurrentHashMap → 

Java 8 中的 Stream 流除了 map 方法外，还有很多其他方法，这里列举一些常用的：

✅ filter(Predicate<T> predicate)：对流中的元素进行过滤，只保留满足条件的元素。
✅ distinct()：去除流中的重复元素。
✅ sorted()：对流中的元素进行排序，默认为自然排序，也可以传入自定义的 Comparator。
✅ peek(Consumer<T> action)：对流中的元素进行遍历，同时执行指定的操作。
✅ limit(long maxSize)：限制流中元素的数量，只保留前 maxSize 个元素。
✅ skip(long n)：跳过流中的前 n 个元素，只保留剩余的元素。
✅ reduce(BinaryOperator<T> accumulator)：将流中的元素按照指定方式进行归约，返回归约的结果。
✅ collect(Collector<T, A, R> collector)：将流中的元素进行收集，返回指定类型的结果。

这些方法可以组合使用，构成复杂的数据处理操作，实现代码的简洁、高效。

Java和 C++ 不同，C++ 中有引用传递的函数调用方式，而 Java 中只有值传递。

扩展
🔻值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷贝，也就是说传递后就互不相关了。 
🔻引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说 传递前和传递后都指向同一个引用（也就是同一个内存空间）

【注】如果不深究的话，还会一直停留在基本数据类型为值传递，对象类型为引用传递的错误理解中。

1️⃣ JDK 动态代理 
2️⃣ cglib 动态代理
区别：
【答案1】
	JDK 代理有实现接口的类，通过反射实现；cglib 用的是继承，子类拦截父类加上自己的逻辑。
【答案2】
	JDK 动态代理只提供接口的代理，不支持类的代理。
	CGLIB 通过继承的方式，如果某个类被标记为final，则它无法使用CGLIB做动态代理。

✅ Java 8（2014年）：

		▪ Lambda 表达式：简化函数式编程。
		▪ Stream API：用于处理集合，支持函数式操作，如过滤、映射和聚合。
		▪ 默认方法：在接口中提供默认实现，提高接口的灵活性。
		▪ Optional 类：减少空指针异常，提高代码可读性。
		▪ 时间 API：提供了一组强大的时间操作类，简化了日期和时间的操作。
		▪ 重复注解：允许在同一个地方多次声明同一个注解，提高了代码的可读性。
		▪ CompletableFuture 类：简化异步编程，提供更好的错误处理和异常处理机制。
		▪ 方法引用：允许直接引用现有方法或构造函数，避免了重复编写类似的代码。
		▪ Nashorn 引擎：提供了一种基于 JavaScript 的解决方案，允许将 JavaScript 代码嵌入到 Java 应用程序中。


✅ Java 9（2017年）：

		▪ 模块系统（Project Jigsaw）：将 Java 的庞大代码库划分为可重用的模块，简化大型应用的构建和维护。
		▪ 改进的 JShell 工具：Java 的交互式命令行工具，用于快速尝试和测试 Java 代码片段。
		▪ 新的集合工厂方法：方便地创建不可变集合，如 List.of()、Set.of() 和 Map.of()。
		▪ 改进的 Stream API：提供了更多的流操作方法，使流操作更加强大和灵活
		▪ Reactive Streams：提供了一种标准化的异步流处理框架
		▪ 改进的 Optional 类：提供了更多的 API 方法和更好的 null 值处理机制
		▪ HTTP 2 客户端：支持 HTTP/2 协议的客户端 API


✅ Java 10（2018年）：

		▪ 局部变量类型推断：使用 var 关键字自动推断局部变量的类型，简化代码。
		▪ 线程局部变量回收：提供了一种新的垃圾回收器，可用于回收线程局部变量。
		▪ 应用类数据共享：允许多个 Java 应用程序共享类数据。
		▪ G1 垃圾回收器改进：提高了垃圾回收的效率和稳定性。
		▪ 垃圾收集器接口改进：提高了垃圾收集器的可插拔性和灵活性。
		▪ 基于时间的版本控制系统：允许使用时间作为版本号来管理代码版本。
		▪ 针对低内存设备的堆分配器：为低内存设备提供更好的内存管理机制。

✅ Java 11（2018年，长期支持版本）：

		▪ 新的 HTTP 客户端 API：支持 HTTP/2 和 WebSocket，提供了更现代化的编程方式。
		▪ 改进的垃圾收集：引入了 ZGC 和 Epsilon 垃圾收集器。
		▪ String 类的新方法：如 lines()、isBlank()、strip() 等。

✅ Java 12 - 17 的部分新特性：

		▪ Switch 表达式：简化 switch 语句的编写，支持使用箭头语法。
		▪ 文本块：简化多行字符串字面量的表示。
		▪ Records：简化数据类的定义，自动为其生成构造函数、getter、hashCode()、equals() 和 toString() 方法。
		▪ Pattern Matching for instanceof（预览功能）：简化 instanceof 操作符的使用，避免显式类型转换。
		▪ 密封类
		▪ 删除实验性 AOT 和 JIT 编译器
		▪ 特定于上下文的反序列化过滤器


Java 未来的发展趋势将是更加注重性能、安全和可靠性。以下是一些可能会影响 Java 未来发展的趋势：

		▪ 云计算和容器化：Java 非常适合在云环境中使用，因为它具有高度的可移植性和跨平台性。Java 的未来将会更加注重云计算和容器化的支持。
		▪ 数据科学和人工智能：Java 正在逐渐成为数据科学和人工智能领域的重要语言之一，未来 Java 可能会提供更多的支持和功能。
		▪ 静态类型检查：静态类型检查是提高代码质量和可靠性的重要手段，Java 未来可能会提供更加严格和强大的类型检查机制。
		▪ 简化语法：比如 Java 16 中的 Records 和 Sealed Classes 是一种更简洁的语法，未来 Java 可能会继续简化语法以提高代码的可读性和可维护性。

总之，Java 未来将继续发展和改进，以适应不断变化的编程环境和需求。

✅ 只需关注 LTS（长期支持版本）的 Java 8、11、17 即可