Java核心类库实战指南：从原理到代码的完整解析

目录

一、字符串处理：String、StringBuilder与StringBuffer

二、集合框架：List、Set与Map的深度应用

三、日期时间API：LocalDateTime、ZonedDateTime与DateTimeFormatter

四、IO流：文件读写的标准范式

五、多线程与线程池

六、网络编程：TCP通信

七、泛型：Generic Types

八、注解：Annotation

九、反射：Reflection

十、枚举：Enum

Java核心类库是构建企业级应用的基石。对于开发者而言，仅仅知道概念是不够的，必须掌握如何在实际代码中运用这些类来解决并发、IO、数据处理等复杂问题。本文将深入剖析Java核心类库，配合完整的代码示例与图解，带你从理论走向实战。

一、字符串处理：String、StringBuilder与StringBuffer

在Java中，字符串处理占据了极大的比重。理解这三者的区别直接关系到程序的性能与线程安全。

核心原理解析

1.String：不可变字符序列。每次修改都会生成新对象，适用于少量操作。
2.StringBuilder：可变字符序列，非线程安全，性能最高，适用于单线程大量拼接。
3.StringBuffer：可变字符序列，线程安全（方法加锁），适用于多线程环境

实战代码示例

public class StringTest { public static void main(String[] args) { // 1. String的不可变性演示 String str = "Hello"; str.concat(" World"); // 原对象未改变，返回了新对象 System.out.println(str); // 输出: Hello // 2. StringBuilder高效拼接 StringBuilder sb = new StringBuilder(); for (int i = 0; i < 10; i++) { sb.append(i); // 直接在原对象上修改，无内存浪费 } System.out.println("拼接结果: " + sb.toString()); // 3. StringBuffer线程安全演示 // 在多线程环境下，使用StringBuffer保证数据一致性 Thread t1 = new Thread(() -> { StringBuffer buffer = new StringBuffer("A"); buffer.append("B"); System.out.println(buffer); }); t1.start(); } }

二、集合框架：List、Set与Map的深度应用

Java集合框架提供了一套性能优良、使用方便的接口和类，用于存储和操作一组对象。
1.List接口：有序集合，允许重复元素。主要实现类有ArrayList和LinkedList。ArrayList基于动态数组实现，支持随机访问，查询效率高，但插入和删除效率较低；LinkedList基于双向链表实现，插入和删除效率高，但查询效率较低。

2.Set接口：无序集合，不允许重复元素。主要实现类有HashSet和TreeSet。HashSet基于哈希表实现，元素无序；TreeSet基于红黑树实现，元素自然排序或按指定比较器排序。

3.Map接口：键值对集合，键不允许重复。主要实现类有HashMap和TreeMap。HashMap基于哈希表实现，键无序；TreeMap基于红黑树实现，键自然排序或按指定比较器排序。

集合框架是Java最常用的API。选择合适的集合类对于算法效率至关重要。
集合特性对比表

实战代码示例

import java.util.*; public class CollectionTest { public static void main(String[] args) { // 1. List：有序且可重复 List<String> list = new ArrayList<>(); list.add("Apple"); list.add("Banana"); list.add("Apple"); // 允许重复 System.out.println("List内容: " + list); // 2. Set：无序且唯一（自动去重） Set<Integer> set = new HashSet<>(); set.add(1); set.add(2); set.add(1); // 重复元素添加失败 System.out.println("Set内容: " + set); // 输出: [1, 2] // 3. Map：键值对映射 Map<String, Integer> map = new HashMap<>(); map.put("Alice", 25); map.put("Bob", 30); // 获取值 System.out.println("Alice的年龄: " + map.get("Alice")); // 遍历Map for (Map.Entry<String, Integer> entry : map.entrySet()) { System.out.println(entry.getKey() + " = " + entry.getValue()); } } }

三、日期时间API：LocalDateTime、ZonedDateTime与DateTimeFormatter

旧的Date和SimpleDateFormat存在线程安全和设计糟糕的问题。Java 8引入的java.time包彻底解决了这些痛点。
核心类说明
1.LocalDateTime：本地日期时间，无时区。
2.ZonedDateTime：带时区的日期时间。
3.DateTimeFormatter：线程安全的格式化类。

新日期时间API的设计更加清晰、易用，且避免了旧版API的线程安全问题。

实战代码示例

import java.time.*; import java.time.format.DateTimeFormatter; public class DateTest { public static void main(String[] args) { // 1. 获取当前时间 LocalDateTime now = LocalDateTime.now(); System.out.println("当前时间: " + now); // 2. 格式化与解析 (线程安全) DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); String formatted = now.format(formatter); System.out.println("格式化: " + formatted); // 3. 时间计算 (不可变对象，返回新实例) LocalDateTime future = now.plusDays(7).plusHours(3); System.out.println("一周后: " + future.format(formatter)); // 4. 时区处理 ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai")); System.out.println("上海时间: " + zonedDateTime); } }

四、IO流：文件读写的标准范式

IO流分为字节流（处理二进制，如图片）和字符流（处理文本）。现代Java开发推荐使用try-with-resources语法自动关闭资源。
IO流分类图解
1.字节流：InputStream / OutputStream (基类) -> FileInputStream / FileOutputStream
2.字符流：Reader / Writer (基类) -> FileReader / FileWriter

在实际开发中，处理文本文件时，应优先使用字符流，因为它可以自动处理字符编码问题；处理图片、音频、视频等二进制文件时，则应使用字节流。

实战代码示例：文件复制

import java.io.*; public class IOTest { public static void main(String[] args) { // 使用try-with-resources自动关闭流 // 场景：使用缓冲字节流高效复制文件 try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.jpg")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("target.jpg"))) { byte[] buffer = new byte[1024]; int len; while ((len = bis.read(buffer)) != -1) { bos.write(buffer, 0, len); } System.out.println("文件复制完成！"); } catch (IOException e) { e.printStackTrace(); } } }

五、多线程与线程池

Java从语言层面支持多线程编程。

直接使用new Thread()在生产环境中是不可取的，因为它消耗资源且难以管理。必须使用线程池（ExecutorService）来管理线程生命周期。

1.Thread类：代表一个线程。可以通过继承Thread类并重写run方法来创建线程。
2.Runnable接口：代表一个可执行的任务。可以通过实现Runnable接口并将其传递给Thread对象来创建线程。
3.ExecutorService接口：是Java 5引入的线程池框架的核心接口，用于管理线程的生命周期和任务调度。使用线程池可以有效控制线程数量，避免频繁创建和销毁线程带来的性能开销。
在实际开发中，推荐使用Runnable接口或ExecutorService框架来管理线程，而不是直接继承Thread类。

线程池工作流程
1.提交任务。
2.核心线程数未满，创建核心线程执行。
3.核心线程已满，任务进入队列。
4.队列已满，创建非核心线程执行。
5.所有线程已满且队列已满，触发拒绝策略。

实战代码示例

import java.util.concurrent.*; public class ThreadPoolTest { public static void main(String[] args) { // 自定义线程池参数 // 核心线程数3，最大线程数5，队列容量4 ExecutorService pool = new ThreadPoolExecutor( 3, 5, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：由调用线程处理 ); // 提交任务 for (int i = 0; i < 10; i++) { final int taskId = i; pool.execute(() -> { System.out.println("任务 " + taskId + " 正在由 " + Thread.currentThread().getName() + " 执行"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); } // 关闭线程池 pool.shutdown(); } }

六、网络编程：TCP通信

Java通过Socket实现网络通信。TCP协议提供可靠的、面向连接的通信。
TCP通信流程
1.服务端：ServerSocket -> accept() -> Socket -> getInputStream()
2.客户端：Socket -> getOutputStream()

Java的网络编程API使得编写客户端和服务器端程序变得简单。
1.Socket类：代表客户端套接字，用于与服务器建立连接并进行数据通信。
2.ServerSocket类：代表服务器端套接字，用于监听客户端的连接请求。
通过Socket和ServerSocket，可以轻松实现TCP协议的网络通信。

实战代码示例

// 服务端代码 import java.io.*; import java.net.*; public class TcpServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8888); System.out.println("服务端启动，等待连接..."); // 阻塞等待客户端连接 Socket socket = serverSocket.accept(); // 读取客户端消息 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); String msg = reader.readLine(); System.out.println("收到消息: " + msg); // 回复客户端 PrintWriter writer = new PrintWriter(socket.getOutputStream(), true); writer.println("服务端已收到"); socket.close(); serverSocket.close(); } }

七、泛型：Generic Types

核心概念
泛型本质上是“参数化类型”。它允许你在定义类、接口和方法时，将类型（如 Integer, String）当作参数传递进来。
1.作用：提高代码复用性，最重要的是在编译期进行类型检查，避免运行时出现 ClassCastException（类型转换异常）。
2.图解：泛型就像一个“模具”。你不需要为 Integer 做一个盒子，为 String 做一个盒子，你只需要做一个泛型盒子 Box<T>，使用时指定 T 是什么即可。

泛型的主要好处是：

1.类型安全：在编译期检查类型，避免运行时ClassCastException。
2.代码复用：可以编写适用于多种类型的通用代码。
3.消除强制类型转换：使用泛型后，无需在获取集合元素时进行强制类型转换。

代码示例

// 1. 定义一个泛型类 // T 代表 Type，是一个占位符，在创建对象时确定具体类型 public class Box<T> { private T content; public void set(T content) { this.content = content; } public T get() { return content; } } public class GenericTest { public static void main(String[] args) { // 2. 使用时指定类型为 String Box<String> stringBox = new Box<>(); stringBox.set("Hello Java"); // stringBox.set(100); // 编译报错：类型不匹配，这就是泛型的安全性 String content = stringBox.get(); // 无需强制转换，直接就是 String 类型 System.out.println(content); // 3. 使用时指定类型为 Integer Box<Integer> intBox = new Box<>(); intBox.set(123); Integer num = intBox.get(); } }

八、注解：Annotation

核心概念

注解是代码中的“标签”或“元数据”。它本身不直接执行业务逻辑，但可以被编译器或运行时环境（如 Spring 框架）读取，从而改变程序的行为。

1.常见内置注解：@Override（检查重写）、@Deprecated（标记过时）。
2.图解：就像给快递包裹贴标签（“易碎”、“加急”）。快递员（编译器/框架）看到标签后，会采取不同的处理方式。
代码示例（自定义注解 + 反射读取）

import java.lang.annotation.*; // 1. 定义注解 // @Retention(RetentionPolicy.RUNTIME) 表示注解在运行时可见，可通过反射读取 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) // 表示该注解只能用在方法上 public @interface MyLog { String value() default "执行了方法"; } // 2. 使用注解 class UserService { @MyLog("用户登录操作") // 给方法打上标签 public void login() { System.out.println("用户正在登录..."); } public void logout() { System.out.println("用户退出..."); } } // 3. 解析注解（模拟框架行为） public class AnnotationTest { public static void main(String[] args) throws Exception { UserService service = new UserService(); // 模拟框架拦截：检查方法上是否有 @MyLog 注解 var method = UserService.class.getMethod("login"); // 判断是否存在该注解 if (method.isAnnotationPresent(MyLog.class)) { MyLog log = method.getAnnotation(MyLog.class); System.out.println("日志记录: " + log.value()); // 输出注解里的值 } method.invoke(service); // 执行方法 } }

九、反射：Reflection

核心概念

反射机制允许程序在运行时动态地加载类、获取类的信息（字段、方法、构造器）并操作对象。

1.作用：它是框架（如 Spring 的依赖注入、MyBatis 的数据库映射）的灵魂。它打破了封装性，提供了极大的灵活性。
2.图解：普通调用是“你点菜（写死代码），厨师做”；反射是“你给厨师一张纸条（类名字符串），厨师照着纸条找食材做菜”。

反射的主要应用场景包括：
1.框架开发：如Spring、MyBatis等框架大量使用反射来实现依赖注入、ORM映射等功能。
2.动态代理：如AOP（面向切面编程）的实现。
3.通用工具类：如对象拷贝、属性赋值等。

代码示例

import java.lang.reflect.Constructor; import java.lang.reflect.Method; class Person { private String name; public Person() {} // 无参构造 public void sayHello(String msg) { System.out.println("Person says: " + msg); } } public class ReflectionTest { public static void main(String[] args) throws Exception { // 1. 获取 Class 对象 (类加载) Class<?> clazz = Class.forName("Person"); // 2. 创建实例 (调用无参构造) Constructor<?> constructor = clazz.getConstructor(); Object personObj = constructor.newInstance(); // 3. 获取并调用方法 // getMethod(方法名, 参数类型.class) Method method = clazz.getMethod("sayHello", String.class); // invoke(对象实例, 参数值) method.invoke(personObj, "Hello Reflection!"); // 输出: Person says: Hello Reflection! } }

十、枚举：Enum

核心概念

枚举用于定义一组固定的常量。相比 public static final int，枚举是类型安全的，且功能更强大（可以有构造器、方法、属性）。

图解：就像交通信号灯，只有“红、黄、绿”三种状态，不能是“紫色”或“黑色”。

枚举类型的主要好处是：
1.类型安全：枚举常量是类型安全的，不能随意赋值。
2.可读性强：枚举常量的名称清晰易懂。
3.功能强大：枚举类型可以包含字段、方法、构造器等，功能非常强大。

代码示例

// 1. 定义枚举类 // 枚举类隐式继承自 java.lang.Enum，不能继承其他类 public enum Season { // 必须在第一行列出所有常量实例 SPRING("春天", "温暖"), SUMMER("夏天", "炎热"), AUTUMN("秋天", "凉爽"), WINTER("冬天", "寒冷"); private String name; private String desc; // 枚举的构造器必须是私有的 private Season(String name, String desc) { this.name = name; this.desc = desc; } public void showInfo() { System.out.println(this.name + " 是 " + this.desc + " 的季节"); } } public class EnumTest { public static void main(String[] args) { // 2. 使用枚举 Season current = Season.SPRING; // 3. 调用枚举的方法 current.showInfo(); // 输出: 春天 是 温暖 的季节 // 4. switch 语句中使用枚举（非常常见） switch (current) { case SPRING: System.out.println("去踏青"); break; case WINTER: System.out.println("去滑雪"); break; default: System.out.println("在家休息"); } } }

这四大核心特性构成了现代 Java 开发的骨架：

1.泛型：保证了集合和工具类的类型安全。
2.注解：简化了配置，让代码更整洁（Spring Boot 的核心）。
3.反射：提供了动态扩展的能力，是框架自动化的基础。
4.枚举：规范了常量的定义，避免了魔法值（Magic Number）带来的错误。

总结
Java核心类库博大精深，本文选取了开发中最常用的六大板块进行了实战解析。掌握这些内容，不仅能帮助你写出更规范的代码，还能让你在面对性能瓶颈时知道如何优化（例如使用StringBuilder代替String拼接，使用线程池代替原生线程）。建议在实际项目中多加练习，体会这些类的设计之美。