Java 核心知识点

int a = 100;                    // 基本类型
Integer b = Integer.valueOf(100); // 包装类（推荐，复用缓存 -128~127）
Integer c = 100;                 // 自动装箱（Auto-boxing，编译后等价于 Integer.valueOf(100)）
int d = c;                       // 自动拆箱（Unboxing）

var list = new ArrayList<String>();  // 编译器推断为 ArrayList<String>
var name = "Hello";                   // 推断为 String
// var x;  ❌ 编译错误，必须初始化

// 声明与初始化
int[] arr1 = new int[5];              // 默认值 0
int[] arr2 = {1, 2, 3, 4, 5};       // 静态初始化
int[] arr3 = new int[]{1, 2, 3};    // 匿名数组

// 多维数组
int[][] matrix = new int[3][4];
int[][] jagged = {{1, 2}, {3, 4, 5}}; // 锯齿数组

// 数组工具类
Arrays.sort(arr1);                     // 排序
Arrays.binarySearch(arr1, 3);          // 二分查找
Arrays.copyOf(arr1, 10);               // 扩容
Arrays.toString(arr1);                 // 打印

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);        // false，比较引用地址
System.out.println(s1.equals(s2));   // true，比较内容

// if-else
if (condition) { ... } else if (condition2) { ... } else { ... }

// switch（支持 byte/short/int/char/String/枚举）
switch (value) {
    case 1: ... break;
    case 2: ... break;
    default: ...
}

String result = switch (day) {
    case MONDAY, FRIDAY -> "工作日";
    case SATURDAY, SUNDAY -> "周末";
    default -> "未知";
};

while (condition) { ... }
do { ... } while (condition);
for (int i = 0; i < 10; i++) { ... }
for (Type item : collection) { ... }  // 增强 for，适用于数组和 Iterable

public class Person {
    // 成员变量（字段）
    private String name;
    private int age;

    // 静态变量
    public static final String SPECIES = "Homo sapiens";

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

    // 实例方法
    public String getName() { return name; }

    // 静态方法
    public static void printSpecies() {
        System.out.println(SPECIES);
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);  // 调用父类构造方法
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" + super.toString() + ", school='" + school + "'}";
    }
}

// 编译时类型 = Person，运行时类型可能是 Student
Person p = new Student("Alice", 20, "PKU");
p.getName();          // 调用 Person.getName() —— 不涉及多态
p.toString();         // 调用 Student.toString() —— 运行时多态

// 向下转型（需要确认类型）
if (p instanceof Student) {
    Student s = (Student) p;
    s.getSchool();
}

// Pattern Matching for instanceof [JDK 16+]
if (p instanceof Student s) {
    System.out.println(s.getSchool());
}

// 接口
public interface Flyable {
    void fly();                              // 抽象方法

    default void land() {                     // 默认方法 [JDK 8+]
        System.out.println("准备着陆...");
    }

    static String getType() {                 // 静态方法 [JDK 8+]
        return "飞行物";
    }

    private void checkWeather() {             // 私有方法 [JDK 9+]
        // 内部复用逻辑
    }
}

// 匿名内部类 → Lambda 表达式简化
button.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e) {
        System.out.println("clicked");
    }
});

// Lambda 等价写法 [JDK 8+]
button.addActionListener(e -> System.out.println("clicked"));

public enum Day {
    MONDAY("周一"), TUESDAY("周二"), WEDNESDAY("周三");

    private final String chineseName;

    Day(String name) { this.chineseName = name; }   // 枚举构造方法默认 private

    public String getChineseName() { return chineseName; }
}

Day today = Day.MONDAY;
System.out.println(today.name());         // "MONDAY"
System.out.println(today.ordinal());      // 0
System.out.println(today.getChineseName()); // "周一"
Day d = Day.valueOf("MONDAY");            // 字符串转枚举

// 自动生成：构造方法、equals()、hashCode()、toString()、getter（无 get 前缀）
public record Point(int x, int y) {
    // 紧凑构造方法（校验）
    public Point {
        if (x < 0 || y < 0) throw new IllegalArgumentException();
    }
    // 可添加实例方法
    public int distance() { return x + y; }
}

Point p = new Point(3, 4);
System.out.println(p.x());    // 3（访问器，方法名 = 字段名）
System.out.println(p);        // Point[x=3, y=4]

try {
    // 可能抛出异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.err.println("算术异常: " + e.getMessage());
} catch (Exception e) {
    System.err.println("其他异常: " + e);
} finally {
    // 无论是否异常都会执行（资源释放）
    System.out.println("finally 块执行");
}

// try-with-resources [JDK 7+]：自动关闭资源
try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    String line = br.readLine();
} catch (IOException e) {
    e.printStackTrace();
}
// 无需手动 close()，实现了 AutoCloseable 接口的资源会自动关闭

// String 不可变 —— 每次拼接都产生新对象
String s = "Hello";
s = s + " World";  // 创建新 String 对象

// String 常量池（字符串池）
String a = "abc";           // 字面量，指向常量池
String b = "abc";           // 指向同一常量池对象
String c = new String("abc"); // 强制在堆上创建新对象
System.out.println(a == b);  // true
System.out.println(a == c);  // false

// intern() 将堆上 String 放入常量池
System.out.println(a == c.intern()); // true

// StringBuilder 高效拼接
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
String result = sb.toString();

// 文本块（Text Block）[JDK 13 预览，15 正式]
String json = """
    {
        "name": "Alice",
        "age": 20
    }
    """;

// 包装类常量与方法
Integer.MAX_VALUE;           // 2147483647
Integer.parseInt("123");     // String → int
Integer.valueOf(100);        // int → Integer（使用缓存 -128 ~ 127）

// Math 工具
Math.abs(-5);                // 5
Math.max(3, 7);              // 7
Math.pow(2, 10);             // 1024.0
Math.sqrt(16);               // 4.0
Math.random();               // [0.0, 1.0) 随机数
Math.round(3.5);             // 4（四舍五入）
Math.floor(3.9);             // 3.0
Math.ceil(3.1);              // 4.0

LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(2000, 1, 15);
Period age = Period.between(birthday, today);
long days = ChronoUnit.DAYS.between(birthday, today);

String formatted = LocalDateTime.now()
    .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

// JDK 5 之前
List list = new ArrayList();
list.add("hello");
list.add(123);
String s = (String) list.get(0);  // 需要强制转换，容易出错

// JDK 5+ 泛型
List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123);   ❌ 编译错误
String s = list.get(0);           // 无需强制转换

// 泛型类
public class Box<T> {
    private T content;
    public T get() { return content; }
    public void set(T content) { this.content = content; }
}

// 泛型接口
public interface Repository<T, ID> {
    T findById(ID id);
    void save(T entity);
}

// 泛型方法
public static <T> T getFirst(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// PECS 原则示例
public void copy(List<? extends Number> src, List<? super Number> dest) {
    for (Number n : src) {     // 安全读取（生产者 extends）
        dest.add(n);            // 安全写入（消费者 super）
    }
}

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass() == list2.getClass());  // true（都是 ArrayList.class）

List<Integer> list = new ArrayList<>();
list.add(1);                    // 尾部追加
list.add(0, 0);                 // 指定位置插入
list.get(0);                    // 按索引访问
list.remove(0);                 // 按索引删除
list.remove(Integer.valueOf(1));// 按元素删除
list.contains(1);               // 是否包含
list.sort(Comparator.reverseOrder()); // 排序

// List 转数组
Integer[] arr = list.toArray(new Integer[0]);

Map<String, Integer> map = new HashMap<>();
map.put("Alice", 95);
map.get("Alice");               // 95
map.getOrDefault("Bob", 0);     // 不存在返回 0
map.containsKey("Alice");       // true
map.putIfAbsent("Alice", 100);  // 只有不存在时才放入
map.computeIfAbsent("Bob", k -> 0); // 不存在时计算放入
map.merge("Alice", 5, Integer::sum); // 合并值

// 遍历
map.forEach((k, v) -> System.out.println(k + " = " + v));
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

Collections.sort(list);                // 排序（要求元素实现 Comparable）
Collections.sort(list, comparator);    // 自定义排序
Collections.reverse(list);             // 反转
Collections.shuffle(list);             // 随机打乱
Collections.max(list);                 // 最大值
Collections.min(list);                 // 最小值
Collections.binarySearch(list, key);   // 二分查找（前提：已排序）
Collections.synchronizedList(list);    // 包装为线程安全（性能差）
Collections.unmodifiableList(list);    // 包装为不可修改

List<String> list = List.of("a", "b", "c");    // 不可变，null 不允许
Map<String, Integer> map = Map.of("a", 1, "b", 2); // 最多 10 对键值

// Comparable：类内部定义自然顺序
public class Student implements Comparable<Student> {
    @Override public int compareTo(Student o) {
        return this.age - o.age;
    }
}

// Comparator：外部灵活定制（Lambda 简化）[JDK 8+]
students.sort(Comparator.comparing(Student::getAge)
        .thenComparing(Student::getName)
        .reversed());

List<String> names = students.stream()
    .filter(s -> s.getScore() >= 60)           // 过滤
    .sorted(Comparator.comparing(Student::getScore).reversed()) // 排序
    .skip(0).limit(10)                          // 分页
    .map(Student::getName)                      // 转换
    .collect(Collectors.toList());              // 收集

// 分组
Map<String, List<Student>> byGrade = students.stream()
    .collect(Collectors.groupingBy(s -> s.getScore() >= 60 ? "及格" : "不及格"));

// 规约
int total = students.stream()
    .mapToInt(Student::getScore).sum();

Optional<Student> top = students.stream()
    .max(Comparator.comparing(Student::getScore));

// 字节流文件复制
try (FileInputStream fis = new FileInputStream("src.txt");
     FileOutputStream fos = new FileOutputStream("dest.txt")) {
    byte[] buffer = new byte[8192];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
    }
}

// 字符缓冲流逐行读取
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

// Path 与 Files 工具（替代 File 类）
Path path = Paths.get("/tmp/test.txt");
List<String> lines = Files.readAllLines(path);                     // 一次性读所有行
Files.write(path, lines, StandardCharsets.UTF_8);                 // 一次性写入
Files.walk(Paths.get("/tmp"))                                      // 递归遍历文件树
    .filter(Files::isRegularFile)
    .forEach(System.out::println);

// 实现 Serializable 接口标记可序列化
public class User implements Serializable {
    private static final long serialVersionUID = 1L;  // 版本号
    private String name;
    private transient String password;  // transient 字段不参与序列化
}

// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
    oos.writeObject(user);
}

// 反序列化（不调用构造方法）
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
    User user = (User) ois.readObject();
}

// 方式一：继承 Thread
class MyThread extends Thread {
    @Override public void run() { System.out.println("子线程运行"); }
}
new MyThread().start();

// 方式二：实现 Runnable（推荐，解耦）
new Thread(() -> System.out.println("子线程运行")).start();

// 方式三：实现 Callable + Future（有返回值、可抛异常）
FutureTask<String> task = new FutureTask<>(() -> "结果");
new Thread(task).start();
String result = task.get();  // 阻塞等待结果

// 同步代码块
synchronized (lock) { ... }

// 同步实例方法（锁当前对象 this）
public synchronized void method() { ... }

// 同步静态方法（锁 Class 对象）
public static synchronized void staticMethod() { ... }

ReentrantLock lock = new ReentrantLock();
try {
    lock.lock();
    // 临界区代码
} finally {
    lock.unlock();  // 务必在 finally 中释放
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4,                        // corePoolSize：核心线程数
    10,                       // maximumPoolSize：最大线程数
    60L, TimeUnit.SECONDS,    // keepAliveTime：空闲线程存活时间
    new LinkedBlockingQueue<>(100), // workQueue：任务队列
    new ThreadPoolExecutor.CallerRunsPolicy() // rejectedExecutionHandler：拒绝策略
);

// 提交任务
executor.execute(() -> { ... });           // Runnable，无返回值
Future<String> future = executor.submit(() -> "result");  // Callable，有返回值

// 优雅关闭
executor.shutdown();        // 不再接受新任务，等待已提交任务完成
executor.awaitTermination(60, TimeUnit.SECONDS);

// CountDownLatch 示例：主线程等待所有子任务完成
CountDownLatch latch = new CountDownLatch(5);
for (int i = 0; i < 5; i++) {
    new Thread(() -> {
        doWork();
        latch.countDown();
    }).start();
}
latch.await();  // 阻塞直到计数归零

// BlockingQueue 生产者-消费者模型
BlockingQueue<String> queue = new LinkedBlockingQueue<>(100);

// 生产者
queue.put(item);    // 队列满时阻塞

// 消费者
String item = queue.take(); // 队列空时阻塞

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();     // 自增并返回（原子操作）
counter.compareAndSet(5, 10);  // CAS：期望值 5 时设置为 10

ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(
    () -> new SimpleDateFormat("yyyy-MM-dd")
);
String date = formatter.get().format(new Date());
// 使用后应在 finally 中 remove() 防止内存泄漏
formatter.remove();

// 创建虚拟线程
Thread vThread = Thread.ofVirtual().start(() -> {
    System.out.println("虚拟线程运行");
});

// 通过 ExecutorService 使用
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> { ... });
    executor.submit(() -> { ... });
}
// try-with-resources 自动等待所有任务完成

// 获取 Class 对象的三种方式
Class<?> clazz1 = String.class;
Class<?> clazz2 = "hello".getClass();
Class<?> clazz3 = Class.forName("java.lang.String");  // 可能抛 ClassNotFoundException

// 创建实例
Object obj = clazz1.getDeclaredConstructor().newInstance();

// 获取方法并调用
Method method = clazz1.getMethod("length");
int length = (int) method.invoke("hello");

// 获取字段并修改
Field field = clazz1.getDeclaredField("value");  // String 的 value[]
field.setAccessible(true);  // 突破 private 限制
char[] value = (char[]) field.get("hello");

// 获取构造方法
Constructor<?> cons = clazz1.getConstructor(String.class);
String str = (String) cons.newInstance("hello");

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    String value() default "";
    boolean recordTime() default true;
}

// 使用注解
@Log(value = "用户登录", recordTime = true)
public void login() { ... }

// Sealed Class [JDK 17+]
public sealed class Shape permits Circle, Rectangle, Triangle { }
public final class Circle extends Shape { }
// 限制哪些类可以继承 Shape，增强类型安全性

// Pattern Matching for switch [JDK 21 正式]
String result = switch (obj) {
    case Integer i -> "整数: " + i;
    case String s  -> "字符串: " + s;
    case null      -> "空值";
    default        -> "未知类型";
};