Java核心特性与开发环境搭建详解

1. Java基础概念与核心特性解析

Java作为一门诞生于1995年的编程语言，至今仍保持着强大的生命力。它的核心设计理念"Write Once, Run Anywhere"（一次编写，到处运行）通过JVM（Java虚拟机）的实现，彻底改变了软件开发的方式。不同于C/C++等需要针对不同操作系统重新编译的语言，Java源代码会被编译成与平台无关的字节码（.class文件），然后由各平台上的JVM解释执行。

注意：JDK（Java Development Kit）是开发Java应用的完整套件，包含了JRE（Java Runtime Environment）和开发工具。而JRE又包含了运行Java程序所需的JVM和核心类库。

Java的三大核心特性值得深入理解：

面向对象：Java是纯粹的面向对象语言（除了8种基本数据类型），所有代码都必须写在类中。封装、继承、多态这三大特性在Java中有着严格的语法支持。例如，类的访问控制通过public/protected/private等修饰符实现，方法重写（Override）必须遵循"两同两小一大"规则（方法名相同、参数列表相同；子类返回值类型小于等于父类、子类抛出异常小于等于父类；子类访问权限大于等于父类）。

自动内存管理：Java通过垃圾回收机制（GC）自动管理堆内存，开发者无需手动释放对象内存。但这也带来了内存泄漏的风险——当对象不再被使用却仍被引用时，GC无法回收它们。常见的内存泄漏场景包括静态集合持有对象、未关闭的资源（如数据库连接）、监听器未注销等。

异常处理机制：Java强制检查异常（Checked Exception）必须被捕获或声明抛出，这促使开发者编写更健壮的代码。异常分类如下：

• Error：系统级错误（如OutOfMemoryError），通常不可恢复
• RuntimeException：运行时异常（如NullPointerException），通常由编程错误导致
• 其他Exception：检查异常（如IOException），必须处理

2. 开发环境搭建与配置详解

2.1 JDK版本选择与安装

当前主流JDK版本包括：

• Java 8（LTS）：最稳定的企业级版本，2023年仍有75%的生产环境在使用
• Java 11（LTS）：引入了var局部变量类型推断、HTTP Client API等新特性
• Java 17（LTS）：最新的长期支持版本，支持密封类（sealed class）、模式匹配等

安装步骤（以Windows为例）：

1. 从Oracle官网或镜像站点下载对应版本的JDK安装包
2. 运行安装程序，建议使用默认路径（如C:\Program Files\Java\jdk-17）
3. 配置环境变量：
   • JAVA_HOME：指向JDK安装目录（如C:\Program Files\Java\jdk-17）
   • Path：添加%JAVA_HOME%\bin
4. 验证安装：命令行执行java -version和javac -version

常见问题：如果遇到"java: 无法编译为 jvm 目标 5"这类版本不匹配错误，需检查：

• 项目配置的Java版本
• 环境变量中JAVA_HOME指向的JDK版本
• IDE中设置的编译器版本

2.2 开发工具选择

主流Java IDE对比：

对于初学者，推荐使用IntelliJ IDEA Community版，它提供了：

• 智能代码提示（如.stream()后自动提示集合操作）
• 可视化调试工具（可查看变量值、表达式求值）
• 内置版本控制（Git）支持
• 丰富的插件市场（如Lombok、CheckStyle）

3. Java核心语法精要

3.1 基础数据类型与运算符

Java有8种基本数据类型：

注意：浮点数比较不能直接用==，应使用Math.abs(a - b) < 0.000001这种方式

运算符优先级（从高到低）：

1. 括号()、[]、.
2. 单目运算符（++、--、!、~）
3. 算术运算符（*、/、% → +、-）
4. 移位运算符（<<、>>、>>>）
5. 关系运算符（<、<=、>、>=、instanceof）
6. 相等运算符（==、!=）
7. 位运算符（& → ^ → |）
8. 逻辑运算符（&& → ||）
9. 三元运算符（?:）
10. 赋值运算符（=、+=等）

3.2 流程控制与数组

分支结构：

java复制// if-else
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else {
    System.out.println("C");
}

// switch (Java 12+支持表达式形式)
String grade = switch (score / 10) {
    case 10, 9 -> "A";
    case 8 -> "B";
    default -> "C";
};

循环结构：

java复制// 传统for循环
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// 增强for循环（foreach）
int[] nums = {1, 2, 3};
for (int num : nums) {
    System.out.println(num);
}

// while循环
int i = 0;
while (i < 10) {
    System.out.println(i++);
}

// do-while循环
int j = 0;
do {
    System.out.println(j++);
} while (j < 10);

数组操作：

java复制// 声明与初始化
int[] arr1 = new int[5];  // 默认值0
int[] arr2 = {1, 2, 3};   // 静态初始化

// 二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

// 数组工具类Arrays
Arrays.sort(arr);         // 排序
Arrays.binarySearch(arr, key); // 二分查找
Arrays.copyOf(arr, newLength); // 复制

3.3 面向对象编程核心

类与对象：

java复制public class Person {
    // 字段（成员变量）
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法
    public void introduce() {
        System.out.println("I'm " + name + ", " + age + " years old.");
    }
    
    // Getter/Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// 使用
Person p = new Person("Alice", 25);
p.introduce();

继承与多态：

java复制class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
    
    public void fetch() {
        System.out.println("Dog fetches ball");
    }
}

// 多态示例
Animal a = new Dog();
a.sound();  // 输出"Dog barks"
// a.fetch(); // 编译错误，Animal类没有fetch方法

接口与抽象类：

java复制// 接口（Java 8+）
interface Flyable {
    void fly();  // 抽象方法
    
    default void land() {  // 默认方法
        System.out.println("Landing...");
    }
    
    static boolean isFlyable(Object obj) {  // 静态方法
        return obj instanceof Flyable;
    }
}

// 抽象类
abstract class Bird {
    abstract void sing();  // 抽象方法
    
    void breathe() {       // 具体方法
        System.out.println("Breathing...");
    }
}

class Sparrow extends Bird implements Flyable {
    @Override
    void sing() {
        System.out.println("Chirp chirp");
    }
    
    @Override
    public void fly() {
        System.out.println("Sparrow flying");
    }
}

4. 集合框架与常用工具类

4.1 集合框架体系

Java集合框架主要分为两大类：

• Collection：存储单个元素的集合

  • List：有序、可重复
    • ArrayList：基于动态数组，随机访问快
    • LinkedList：基于双向链表，插入删除快
    • Vector：线程安全的ArrayList（已过时）
  • Set：无序、不可重复
    • HashSet：基于哈希表
    • TreeSet：基于红黑树，有序
    • LinkedHashSet：保持插入顺序
  • Queue：队列
    • LinkedList：也实现了Queue接口
    • PriorityQueue：优先级队列

• Map：存储键值对的映射

  • HashMap：基于哈希表
  • TreeMap：基于红黑树，按键排序
  • LinkedHashMap：保持插入顺序
  • Hashtable：线程安全的HashMap（已过时）
  • ConcurrentHashMap：线程安全的高性能HashMap

集合选择原则：

1. 需要键值对存储？选Map体系
2. 需要排序？TreeSet/TreeMap
3. 需要保持插入顺序？LinkedHashSet/LinkedHashMap
4. 需要线程安全？CopyOnWriteArrayList/ConcurrentHashMap
5. 只需要存储不重复元素？HashSet
6. 需要频繁随机访问？ArrayList
7. 需要频繁插入删除？LinkedList

4.2 泛型与集合操作

泛型示例：

java复制List<String> list = new ArrayList<>();  // 指定元素类型为String
list.add("Java");
// list.add(123);  // 编译错误

Map<Integer, String> map = new HashMap<>();
map.put(1, "One");
map.put(2, "Two");

常用集合操作：

java复制List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 遍历
for (int num : numbers) {
    System.out.println(num);
}

// 使用迭代器
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Java 8+ Stream API
numbers.stream()
       .filter(n -> n % 2 == 0)
       .map(n -> n * 2)
       .forEach(System.out::println);

// 集合工具类Collections
Collections.sort(numbers);  // 排序
Collections.reverse(numbers);  // 反转
Collections.shuffle(numbers);  // 随机打乱

4.3 常用工具类

Arrays：

java复制int[] arr = {3, 1, 4, 1, 5, 9};

Arrays.sort(arr);  // 排序
int index = Arrays.binarySearch(arr, 4);  // 二分查找
int[] copy = Arrays.copyOf(arr, arr.length);  // 复制
boolean equal = Arrays.equals(arr, copy);  // 比较
String str = Arrays.toString(arr);  // 转字符串

Objects：

java复制// 安全地比较对象
boolean isEqual = Objects.equals(obj1, obj2);

// 安全的hashCode计算
int hash = Objects.hash(name, age, address);

// 非空检查
String value = Objects.requireNonNull(input, "Input cannot be null");

Math：

java复制double pi = Math.PI;
int max = Math.max(10, 20);  // 20
double sqrt = Math.sqrt(25);  // 5.0
double random = Math.random();  // [0.0, 1.0)
long round = Math.round(3.6);  // 4

5. 异常处理与IO操作

5.1 异常处理机制

异常处理最佳实践：

java复制try {
    // 可能抛出异常的代码
    FileInputStream fis = new FileInputStream("test.txt");
    // 使用资源
} catch (FileNotFoundException e) {
    // 处理特定异常
    System.err.println("文件未找到: " + e.getMessage());
    // 记录日志
    logger.error("文件操作错误", e);
} catch (IOException e) {
    // 处理更通用的异常
    System.err.println("IO错误: " + e.getMessage());
} finally {
    // 通常用于释放资源（Java 7+推荐使用try-with-resources）
}

// try-with-resources (自动关闭资源)
try (FileInputStream fis = new FileInputStream("test.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

自定义异常：

java复制class InsufficientFundsException extends Exception {
    private double amount;
    
    public InsufficientFundsException(double amount) {
        super("资金不足，还差: " + amount);
        this.amount = amount;
    }
    
    public double getAmount() { return amount; }
}

// 使用
void withdraw(double amount) throws InsufficientFundsException {
    if (balance < amount) {
        throw new InsufficientFundsException(amount - balance);
    }
    balance -= amount;
}

5.2 文件IO操作

传统IO（java.io）：

java复制// 文件读取
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

// 文件写入
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("Hello, Java IO");
    bw.newLine();
    bw.write("Another line");
}

// 二进制文件操作
try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
    dos.writeInt(123);
    dos.writeDouble(3.14);
    dos.writeUTF("字符串");
}

NIO（java.nio）：

java复制Path path = Paths.get("input.txt");
try {
    // 读取所有行
    List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
    
    // 写入文件
    Files.write(Paths.get("output.txt"), 
               "Hello NIO".getBytes(),
               StandardOpenOption.CREATE);
    
    // 使用Files工具类
    boolean exists = Files.exists(path);
    long size = Files.size(path);
    Files.copy(path, Paths.get("backup.txt"));
} catch (IOException e) {
    e.printStackTrace();
}

5.3 序列化与反序列化

Java对象序列化：

java复制class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;  // transient修饰的字段不会被序列化
    
    // 构造方法、getter/setter省略
}

// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("student.dat"))) {
    Student s = new Student("Alice", 20);
    oos.writeObject(s);
}

// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("student.dat"))) {
    Student s = (Student) ois.readObject();
    System.out.println(s.getName());  // Alice
    System.out.println(s.getAge());   // 0 (因为age被transient修饰)
}

注意事项：

1. 序列化ID（serialVersionUID）用于版本控制，建议显式声明
2. 敏感字段应使用transient修饰避免序列化
3. 静态变量不会被序列化
4. 父类如果不可序列化，需要有默认构造方法

6. 多线程编程核心

6.1 线程创建与基本操作

创建线程的三种方式：

java复制// 1. 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}
new MyThread().start();

// 2. 实现Runnable接口
Runnable task = () -> System.out.println("Task running");
new Thread(task).start();

// 3. 实现Callable接口（可返回结果）
Callable<Integer> callable = () -> {
    Thread.sleep(1000);
    return 42;
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
new Thread(futureTask).start();
Integer result = futureTask.get();  // 阻塞获取结果

线程基本操作：

java复制Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);
        System.out.println("Thread completed");
    } catch (InterruptedException e) {
        System.out.println("Thread interrupted");
    }
});

thread.start();  // 启动线程
thread.join();   // 等待线程结束
thread.interrupt();  // 中断线程

6.2 线程同步与锁机制

synchronized关键字：

java复制class Counter {
    private int count;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void add(int value) {
        synchronized(this) {
            count += value;
        }
    }
}

Lock接口：

java复制Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();  // 确保锁被释放
}

线程间通信：

java复制class Message {
    private String content;
    private boolean empty = true;
    
    public synchronized String read() {
        while (empty) {
            try {
                wait();  // 等待写入
            } catch (InterruptedException e) {}
        }
        empty = true;
        notifyAll();
        return content;
    }
    
    public synchronized void write(String content) {
        while (!empty) {
            try {
                wait();  // 等待读取
            } catch (InterruptedException e) {}
        }
        empty = false;
        this.content = content;
        notifyAll();
    }
}

6.3 并发工具类

CountDownLatch：

java复制CountDownLatch latch = new CountDownLatch(3);

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        System.out.println("Thread completed");
        latch.countDown();
    }).start();
}

latch.await();  // 等待所有线程完成
System.out.println("All threads completed");

CyclicBarrier：

java复制CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("All threads reached barrier");
});

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        System.out.println("Thread waiting at barrier");
        try {
            barrier.await();
        } catch (Exception e) {}
    }).start();
}

ThreadPoolExecutor：

java复制ExecutorService executor = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
    });
}

executor.shutdown();  // 关闭线程池

7. JVM核心原理与性能调优

7.1 JVM内存模型

JVM内存主要分为以下几个区域：

1. 程序计数器：线程私有，记录当前线程执行的字节码行号
2. 虚拟机栈：线程私有，存储栈帧（局部变量表、操作数栈等）
3. 本地方法栈：为Native方法服务
4. 堆：所有线程共享，存储对象实例（GC主要工作区域）
5. 方法区：存储类信息、常量、静态变量等（JDK8后称为元空间）

内存溢出场景：

• 堆溢出（OutOfMemoryError: Java heap space）：对象太多，堆空间不足
• 栈溢出（StackOverflowError）：递归调用太深或栈帧过大
• 方法区溢出（OutOfMemoryError: Metaspace）：加载的类太多

7.2 垃圾回收机制

GC算法：

1. 标记-清除：简单但产生内存碎片
2. 复制算法：高效但浪费空间（新生代使用）
3. 标记-整理：适合老年代
4. 分代收集：结合以上算法，按对象生命周期使用不同策略

垃圾收集器：

• Serial：单线程，适合客户端应用
• Parallel Scavenge：吞吐量优先
• CMS：低延迟，已废弃
• G1：平衡吞吐量和延迟（JDK9+默认）
• ZGC：超低延迟（JDK15+生产可用）

GC调优参数示例：

code复制-Xms4g -Xmx4g           # 堆初始和最大大小
-Xmn2g                 # 新生代大小
-XX:+UseG1GC           # 使用G1收集器
-XX:MaxGCPauseMillis=200  # 目标最大GC停顿时间
-XX:ParallelGCThreads=4   # 并行GC线程数
-XX:MetaspaceSize=256m    # 元空间初始大小

7.3 性能监控工具

命令行工具：

• jps：查看Java进程
• jstat：监控JVM统计信息

  code复制jstat -gcutil <pid> 1000  # 每秒显示一次GC情况
  

• jmap：内存分析

  code复制jmap -heap <pid>      # 显示堆概要
  jmap -histo:live <pid> # 显示存活对象统计
  

• jstack：线程分析

  code复制jstack <pid>          # 显示线程栈
  jstack -l <pid>       # 显示锁信息
  

可视化工具：

• JConsole：基本监控
• VisualVM：功能更全面（可安装插件）
• Java Mission Control：商业级监控（JDK自带）

8. Java新特性与编码实践

8.1 Java 8+核心新特性

Lambda表达式：

java复制// 替代匿名内部类
new Thread(() -> System.out.println("Lambda thread")).start();

// 集合操作
list.forEach(item -> System.out.println(item));
list.removeIf(item -> item.startsWith("A"));
list.replaceAll(String::toUpperCase);

Stream API：

java复制List<String> result = list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

Optional：

java复制Optional<String> opt = Optional.ofNullable(getName());
String name = opt.orElse("default");
opt.ifPresent(System.out::println);

模块系统（Java 9）：

java复制module com.example.myapp {
    requires java.base;
    requires java.sql;
    exports com.example.myapp.api;
}

记录类（Java 16）：

java复制record Point(int x, int y) {
    // 自动生成构造方法、getter、equals、hashCode、toString
}

Point p = new Point(10, 20);
System.out.println(p.x());  // 10

8.2 编码最佳实践

1. 命名规范：

   • 类名：大驼峰（如ArrayList）
   • 方法/变量：小驼峰（如getUserName）
   • 常量：全大写+下划线（如MAX_SIZE）
   • 包名：全小写（如com.example.util）

2. 代码组织：

   • 一个类不超过500行
   • 一个方法不超过50行
   • 避免过长参数列表（超过5个考虑用对象封装）
   • 使用final修饰不应被修改的变量/参数

3. 异常处理：

   • 不要捕获Exception这样太通用的异常
   • 不要生吞异常（空的catch块）
   • 自定义异常应提供有用的错误信息
   • 优先使用try-with-resources管理资源

4. 性能注意：

   • 字符串拼接使用StringBuilder
   • 集合初始化指定容量（如new ArrayList<>(100)）
   • 避免在循环中创建大量临时对象
   • 使用基本类型而非包装类（如int而非Integer）

8.3 常见面试问题解析

JVM相关：

1. 描述JVM内存结构
2. GC算法有哪些？各自特点是什么？
3. 如何排查内存泄漏？
4. 什么情况下会触发Full GC？

多线程相关：

1. synchronized和ReentrantLock的区别
2. volatile关键字的作用
3. ThreadLocal原理和使用场景
4. 如何避免死锁？

集合相关：

1. HashMap的实现原理
2. ConcurrentHashMap如何保证线程安全？
3. ArrayList和LinkedList的区别
4. 如何设计一个LRU缓存？

设计模式：

1. 单例模式的几种实现方式
2. Spring中使用了哪些设计模式？
3. 工厂模式和抽象工厂模式的区别
4. 观察者模式的典型应用场景

9. 实战案例：学生管理系统

9.1 需求分析

实现一个控制台版的学生管理系统，功能包括：

1. 添加学生信息（学号、姓名、年龄、成绩）
2. 删除学生信息
3. 修改学生信息
4. 查询学生信息（按学号、姓名等）
5. 统计功能（平均成绩、最高分等）
6. 数据持久化（保存到文件）

9.2 核心实现

学生类：

java复制public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String id;
    private String name;
    private int age;
    private double score;
    
    // 构造方法、getter/setter、toString省略
}

服务类：

java复制public class StudentService {
    private Map<String, Student> students = new HashMap<>();
    
    public void addStudent(Student student) {
        if (students.containsKey(student.getId())) {
            throw new IllegalArgumentException("学号已存在");
        }
        students.put(student.getId(), student);
    }
    
    public Student getStudent(String id) {
        return students.get(id);
    }
    
    public List<Student> searchByName(String name) {
        return students.values().stream()
                .filter(s -> s.getName().contains(name))
                .collect(Collectors.toList());
    }
    
    public double getAverageScore() {
        return students.values().stream()
                .mapToDouble(Student::getScore)
                .average()
                .orElse(0);
    }
    
    // 其他方法省略
}

数据持久化：

java复制public class DataPersistence {
    public static void saveToFile(String filename, Map<String, Student> data) {
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(filename))) {
            oos.writeObject(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    @SuppressWarnings("unchecked")
    public static Map<String, Student> loadFromFile(String filename) {
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(filename))) {
            return (Map<String, Student>) ois.readObject();
        } catch (Exception e) {
            return new HashMap<>();
        }
    }
}

9.3 测试与优化

单元测试：

java复制class StudentServiceTest {
    private StudentService service;
    
    @BeforeEach
    void setUp() {
        service = new StudentService();
        service.addStudent(new Student("001", "Alice", 20, 85.5));
        service.addStudent(new Student("002", "Bob", 21, 76.0));
    }
    
    @Test
    void testAddStudent() {
        assertThrows(IllegalArgumentException.class, 
            () -> service.addStudent(new Student("001", "Charlie", 22, 90.0)));
    }
    
    @Test
    void testAverageScore() {
        assertEquals(80.75, service.getAverageScore(), 0.001);
    }
}

性能优化：

1. 使用ConcurrentHashMap替代HashMap支持并发访问
2. 对大量数据采用分批处理
3. 添加缓存机制（如使用Caffeine缓存热门查询）
4. 采用异步IO进行文件操作

10. 常见问题排查与解决方案

10.1 内存问题排查

内存泄漏排查步骤：

1. 使用jps获取Java进程ID
2. 使用jmap -histo:live <pid>查看对象分布
3. 使用jmap -dump:live,format=b,file=heap.hprof <pid>导出堆转储
4. 使用MAT（Memory Analyzer Tool）分析堆转储文件
5. 查找异常大的对象或对象集合
6. 检查GC Roots到这些对象的引用链

OutOfMemoryError解决方案：

1. 调整JVM参数增加堆大小（-Xmx）
2. 检查是否存在内存泄漏（如静态集合持有对象）
3. 优化数据结构（如使用原始类型集合）
4. 对大对象考虑使用软引用/弱引用
5. 分批处理大数据集

10.2 线程问题排查

死锁检测：

java复制// 使用jstack检测
jstack -l <pid>

// 代码检测
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] threadIds = bean.findDeadlockedThreads();
if (threadIds != null) {
    ThreadInfo[] infos = bean.getThreadInfo(threadIds);
    for (ThreadInfo info : infos) {
        System.out.println(info.getThreadName() + " is deadlocked");
    }
}

高CPU排查：

1. 使用top -H -p <pid>查看高CPU线程
2. 将线程ID转为16进制（printf "%x\n" ）
3. 使用jstack <pid>获取线程栈
4. 查找对应16进制线程ID的栈信息
5. 分析热点代码（如死循环、复杂计算等）

10.3 常见异常处理

NullPointerException预防：

1. 使用Objects.requireNonNull检查参数
2. 使用Optional避免显式null检查
3. 合理设计API（避免返回null）
4. 使用注解（如@Nullable、@NonNull）

ConcurrentModificationException解决：

1. 使用迭代器的remove方法而非集合的remove
2. 遍历时使用CopyOnWriteArrayList
3. 加锁同步访问集合
4. 使用Stream API的toList创建新集合

ClassNotFoundException排查：

1. 检查类路径是否正确
2. 确认依赖是否包含所需类
3. 检查类名拼写是否正确
4. 确认类加载器层次结构

11. Java生态与进阶方向

11.1 主流开发框架

Spring框架体系：

• Spring Core：IoC容器、依赖注入
• Spring MVC：Web框架
• Spring Boot：快速应用开发
• Spring Data：数据访问抽象
• Spring Security：认证授权
• Spring Cloud：微服务架构

ORM框架：

• Hibernate：全功能ORM
• MyBatis：SQL映射框架
• JPA：Java持久化API规范

测试框架：

• JUnit：单元测试
• Mockito：Mock框架
• TestNG：更灵活的测试框架

11.2 构建工具与依赖管理

Maven：

xml复制<!-- pom.xml示例 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.0</version>
    </dependency>
</dependencies>

Gradle：

groovy复制// build.gradle示例
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:2.7.0'
}

11.3 热门技术方向

1. 微服务架构：

   • Spring Cloud Alibaba
   • 服务注册发现（Nacos）
   • 配置中心（Apollo）
   • 服务网关（Gateway）

2. 响应式编程：

   • Reactor
   • WebFlux
   • R2DBC

3. 云原生技术：

   • Docker容器化
   • Kubernetes编排
   • Service Mesh（Istio）

4. 大数据处理：

   • Hadoop生态系统
   • Spark实时计算
   • Flink流处理

5. 性能优化：

   • JVM调优
   • 数据库优化
   • 缓存策略（Redis）
   • 异步处理

12. 学习资源与社区推荐

12.1 官方文档

1. Oracle Java文档
2. OpenJDK文档
3. Java语言规范
4. JVM规范

12.2 推荐书籍

入门：

• 《Java核心技术 卷I》（Cay S. Horstmann）
• 《Head First Java》（Kathy Sierra）

进阶：

• 《Effective Java》（Joshua Bloch）
• 《Java并发编程实战》（Brian Goetz）
• 《深入理解Java虚拟机》（周志明）

架构：

• 《Spring实战》（Craig Walls）
• 《微服务架构设计模式》（Chris Richardson）

12.3 在线资源

1. 视频教程：

   • 慕课网Java全系列
   • B站尚硅谷Java教程

2. 技术社区：

   • Stack Overflow
   • 掘金
   • InfoQ

3. 开源项目：

   • Spring系列项目
   • Apache Commons
   • Guava

12.4 学习路线建议

1. 初级阶段（3-