7.24学习总结

一、今日完成内容
收尾Java SE 剩余知识点学习
补齐了集合底层原理、异常体系、IO 流、多线程、JDK8 新特性、反射注解、枚举等核心模块，完整闭环 Java 基础全套内容；

1. LinkedList
   底层双向链表，内存不连续
   import java.util.LinkedList;
   public class LinkedListTest {
   public static void main(String[] args) {
   LinkedList list = new LinkedList<>();
   // 当作队列 FIFO
   list.offer("A");
   list.offer("B");
   System.out.println(list.poll()); // A

   // 当作栈 LIFO
   list.push("C");
   System.out.println(list.pop()); // C
   }
   }
   对比总结
   ArrayList：查询快，随机访问get(index) O(1)
   LinkedList：头尾增删快，查询需要遍历 O (n)
   2.Set 集合
   HashSet 去重核心规则
   先判断两个对象hashCode()返回值是否相等
   hash 值相等再用equals()比较内容
   全部相等判定为同一个元素，拒绝存入
   自定义实体类必须重写两个方法，否则无法去重：
   class Student {
   private Integer id;
   private String name;
   // 构造、getset省略

   @Override
   public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   Student student = (Student) o;
   return Objects.equals(id, student.id) && Objects.equals(name, student.name);
   }

   @Override
   public int hashCode() {
   return Objects.hash(id, name);
   }
   }
   LinkedHashSet：插入顺序有序
   TreeSet：自然排序，元素实现Comparable，或构造传入Comparator比较器

2. HashMap（面试重中之重）
   JDK8 底层：数组 + 链表 + 红黑树
   默认初始容量 16，负载因子 0.75，扩容为 2 倍
   链表长度≥8 且数组长度≥64，转为红黑树；长度≤6 退回链表
   key 必须重写hashCode和equals，String、Integer 已重写可直接用
   Map 四种遍历方式
   HashMap<String,Integer> map = new HashMap<>();
   map.put("张三",20);

// 1. keySet遍历key
for (String key : map.keySet()) {}
// 2. entrySet键值对（推荐）
for (Map.Entry<String, Integer> entry : map.entrySet()) {}
// 3. values只取值
for (Integer v : map.values()) {}
// 4. Lambda遍历
map.forEach((k,v)-> System.out.println(k+v));
4. 并发修改异常原因
迭代器遍历过程中，集合add/remove修改了 modCount，触发校验抛出ConcurrentModificationException
解决：迭代器自身it.remove()删除、或者用CopyOnWriteArrayList
二、异常体系 Throwable

1. 分类
   Error：系统级错误，OOM、栈溢出，代码无法处理
   Exception：可处理异常
   运行时异常RuntimeException：空指针、数组越界，编译不强制捕获
   受检异常：IO、文件不存在，编译强制 try-catch 或 throws 抛出
   public class ExceptionTest {
   public static void test() throws IOException {
   throw new IOException("文件读取失败");
   }

   public static void main(String[] args) {
   try {
   test();
   } catch (IOException e) {
   e.printStackTrace();
   } finally {
   // 无论是否异常都会执行，唯一不执行：System.exit(0)
   System.out.println("资源释放");
   }
   }
   }

2. 自定义异常
   // 业务异常
   class BusinessException extends RuntimeException {
   public BusinessException(String msg) {
   super(msg);
   }
   }
   // 使用
   if (age < 0) {
   throw new BusinessException("年龄非法");
   }
   三：IO 流 & File 文件操作

3. 分类
   字节流：InputStream/OutputStream 一切文件（图片、视频、文档）
   字符流：Reader/Writer 仅纯文本文件

4. 文件复制经典案例（字节缓冲流）
   import java.io.*;

public class FileCopy {
public static void main(String[] args) {
// try-with-resources 自动关闭流，JDK7+
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"))) {

byte[] buf = new byte[1024];
int len;
while ((len = bis.read(buf)) != -1) {
bos.write(buf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 对象序列化
实体类实现Serializable接口，使用ObjectOutputStream写入文件，反序列化读取
4. File 类常用方法
File file = new File("test.txt");
file.createNewFile(); // 创建文件
file.mkdirs(); // 创建多级文件夹
file.delete(); // 删除文件/空文件夹
file.listFiles(); // 遍历子文件
四：多线程（核心难点）

1. 三种创建方式
   继承 Thread 类，重写 run ()
   实现 Runnable 接口（推荐，避免单继承限制）
   Callable + FutureTask，可以获取返回值、抛异常
   // 方式2 推荐写法
   class MyTask implements Runnable {
   @Override
   public void run() {
   System.out.println("线程执行");
   }
   }

public static void main(String[] args) {
new Thread(new MyTask()).start();
}
2. 线程安全与锁
共享资源多线程并发修改会出现数据错乱
synchronized 同步方法 / 同步代码块
Lock手动锁，可灵活控制加锁解锁
java
运行
// 卖票简单案例
class Ticket implements Runnable {
private int ticket = 100;
private final Lock lock = new ReentrantLock();

@Override
public void run() {
while (true) {
lock.lock();
try {
if (ticket <= 0) break;
System.out.println(Thread.currentThread().getName() + "卖出：" + ticket--);
} finally {
lock.unlock();
}
}
}
}
3. 线程池（项目必用）
避免频繁创建销毁线程损耗性能
java
运行
ExecutorService pool = Executors.newFixedThreadPool(5);
pool.submit(new MyTask());
pool.shutdown();
补充知识点
wait ()/notify ()：等待唤醒机制，必须在同步代码块中
volatile：保证可见性、禁止指令重排，不保证原子性
死锁：互相持有对方需要的锁，规避：统一获取锁顺序
模块五：JDK8 核心新特性（日常高频）

1. Lambda 表达式
   前提：函数式接口（只有一个抽象方法，注解@FunctionalInterface）
   java
   运行
   // 原始写法
   new Thread(new Runnable() {
   @Override
   public void run() {
   System.out.println("老写法");
   }
   }).start();

// Lambda简化
new Thread(() -> System.out.println("Lambda")).start();
2. Stream 流（集合处理神器）
java
运行
List nums = Arrays.asList(1,2,3,4,5);
nums.stream()
.filter(n -> n % 2 == 0) // 过滤偶数
.map(n -> n * 10) // 每个乘10
.sorted() // 排序
.collect(Collectors.toList()); // 转回集合
3. Optional 解决空指针
java
运行
String str = null;
String res = Optional.ofNullable(str).orElse("默认值");
4. 新日期类（替代过时 Date）
java
运行
LocalDateTime now = LocalDateTime.now();
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String time = now.format(formatter);
六：必学知识点

1. 枚举 Enum
   enum Status {
   NORMAL, LOCK, DELETE
   }
   // 使用
   Status s = Status.NORMAL;
   作用：固定状态值，替换魔法数字
2. 反射机制
   运行时动态获取类信息、创建对象、调用方法
   Class<?> clazz = User.class;
   Object obj = clazz.newInstance();
   Method setName = clazz.getDeclaredMethod("setName", String.class);
   setName.invoke(obj, "李四");
3. 注解 & 元注解
   元注解：@Retention、@Target、@Documented、@Inherited
   自定义注解 + 反射解析，框架底层大量使用（Spring、MyBatis）
4. 内部类
   成员内部类、静态内部类、局部内部类、匿名内部类（Lambda 前身）
5. String 三大类区别
   String：不可变字符串，常量池缓存
   StringBuilder：线程不安全，效率高（单线程）
   StringBuffer：加同步锁，线程安全，效率低
   模块七：进阶拓展（后端打底）
   网络编程 Socket：简单 TCP 客户端服务端通信
   SOLID 五大设计原则（对应之前代码美学）
   简单设计模式：单例模式、工厂模式
   泛型擦除底层原理最终复盘

完成数学练习题刷题巩固，
针对计算类题型进行了复盘；

背了英语六级高频核心单词，积累词汇量，为六级备考做准备。

二、明日计划安排
标记 HashMap、多线程锁、Stream 流等重难点方便复盘；
继续推进高数专项题型训练，整理错题本；
复习今日六级背诵单词，并新增一轮新词背诵，尝试简单长难句拆解练习。
三、今日遇到的问题及解决方案
问题：Java 多线程中synchronized与Lock锁适用场景容易混淆，死锁产生条件理解模糊。
解决：代码实操两种锁的写法，整理对比表格，死锁通过模拟代码直观理解四个必要条件，总结出统一锁顺序的规避方案。
问题：高数部分部分公式运用不熟练，做题卡顿。
解决：把对应公式单独摘抄，配套2道基础例题反复演算，固化解题步骤。
问题：六级单词记忆容易遗忘。
解决：采用短时重复回顾法，早上背诵、中午快速过一遍、睡前复盘，加深记忆留存。