1
1. 封装：隐藏内部实现，对外暴露接口
2
2. 继承：子类继承父类的属性和方法
3
3. 多态：同一方法在不同对象上有不同表现（重写/接口实现）
4
4. 抽象：抽象类和接口，定义规范不实现细节

1
重载：同一个类中，方法名相同，参数列表不同，编译时多态
2
重写：子类重新定义父类的方法，运行时多态

1
== ：比较基本类型的值，或引用类型的地址是否相同
2
equals()：Object中的默认实现是==，但String、Integer等类重写了它，
3
          改为比较内容是否相等
4

5
String a = new String("hello");
6
String b = new String("hello");
7
a == b        // false（不同对象）
8
a.equals(b)   // true（内容相同）

1
String：不可变，每次修改创建新对象，线程安全（因为不可变）
2
StringBuilder：可变，非线程安全，性能最高（单线程推荐）
3
StringBuffer：可变，线程安全（方法有synchronized），性能略低

1
- final class：不能被继承
2
- final method：不能被重写
3
- final variable：值不能被修改（基本类型值不变，引用类型地址不变）
4
- final参数：方法内不能修改参数引用

1
ArrayList底层是数组，LinkedList底层是双向链表。
2

3
ArrayList：
4
- 随机访问O(1)
5
- 插入/删除O(n)（需移动元素）
6
- 内存连续，缓存友好
7

8
LinkedList：
9
- 随机访问O(n)（需遍历）
10
- 头尾插入/删除O(1)
11
- 内存不连续，占用更多空间（存储前后指针）

1
JDK1.8之前：数组+链表（头插法）
2
JDK1.8之后：数组+链表+红黑树（尾插法）
3

4
核心参数：
5
- 初始容量：16
6
- 负载因子：0.75
7
- 树化阈值：链表长度≥8且数组长度≥64时转为红黑树
8
- 退化阈值：红黑树节点≤6时转回链表
9

10
put流程：
11
  计算key的hash → 定位数组索引 → 若空直接插入 →
12
  若不空，遍历链表/红黑树 → 找到相同key覆盖，
13
  否则新增 → 检查是否超过阈值，触发resize

1
基于泊松分布，在随机hash下，链表长度达到8的概率极低（约0.00000006），
2
所以8是时间和空间的折中选择。

1
JDK1.7：分段锁（Segment）+ 多次hash
2
JDK1.8：CAS + synchronized + 红黑树
3

4
JDK1.8核心：
5
- 数组+链表+红黑树（和HashMap一样）
6
- 并发安全通过CAS和synchronized实现（锁住数组的单个桶）
7
- 读操作不加锁（volatile保证可见性）
8
- 扩容时多线程协助迁移

1
HashSet：底层HashMap，无序，O(1)，元素需实现hashCode()和equals()
2
TreeSet：底层TreeMap（红黑树），有序（默认自然顺序或Comparator），O(log n)

1
线程私有：
2
  - 程序计数器：当前线程执行的字节码行号
3
  - 虚拟机栈：局部变量表、操作数栈、方法出口
4
  - 本地方法栈：native方法
5

6
线程共享：
7
  - 堆：对象实例、数组（GC主要区域）
8
  - 方法区（元空间）：类信息、常量、静态变量、JIT编译代码

1
1. 标记-清除：标记存活对象→清除未标记的，产生碎片
2
2. 标记-复制：将内存分为两块，存活对象复制到另一块，整块清除
3
3. 标记-整理：标记存活对象→向一端移动→清理边界外
4

5
分代收集：
6
  - 新生代：标记-复制（Eden→Survivor）
7
  - 老年代：标记-整理/标记-清除

1
启动类加载器（Bootstrap ClassLoader）：加载JAVA_HOME/lib
2
扩展类加载器（Extension ClassLoader）：加载JAVA_HOME/lib/ext
3
应用程序类加载器（App ClassLoader）：加载classpath
4

5
双亲委派：一个类加载器收到请求后，先交给父加载器加载，
6
父加载器不能加载时才自己加载。保证核心类不被篡改。

1
synchronized：关键字，自动获取释放锁，支持锁升级（偏向→轻量→重量）
2
Lock：接口，需手动lock/unlock，更灵活（可中断、可超时、可尝试）
3

4
使用Lock的场景：
5
- 需要尝试获取锁（tryLock）
6
- 需要可中断的锁
7
- 需要公平锁
8
- 需要多个条件变量（Condition）

1
保证可见性：对volatile变量的写会立即刷新到主存，读从主存读
2
防止指令重排序：禁止JIT和CPU对volatile变量周围的指令重排
3

4
不保证原子性：i++操作仍然不是线程安全的（需要synchronized或AtomicInteger）

1
ThreadPoolExecutor(int corePoolSize,      // 核心线程数
2
                   int maximumPoolSize,   // 最大线程数
3
                   long keepAliveTime,    // 空闲线程存活时间
4
                   TimeUnit unit,
5
                   BlockingQueue<Runnable> workQueue, // 任务队列
6
                   ThreadFactory threadFactory,
7
                   RejectedExecutionHandler handler) // 拒绝策略

1
AbortPolicy：抛出异常（默认）
2
CallerRunsPolicy：由调用线程执行
3
DiscardPolicy：丢弃任务
4
DiscardOldestPolicy：丢弃队列中最老的任务

1
// Lambda
2
list.forEach(item -> System.out.println(item));
3

4
// Stream
5
list.stream()
6
    .filter(s -> s.startsWith("A"))
7
    .map(String::toUpperCase)
8
    .sorted()
9
    .collect(Collectors.toList());

1
// 避免空指针
2
Optional<String> opt = Optional.ofNullable(getName());
3
String result = opt.orElse("默认值");
4
opt.ifPresent(System.out::println);