Java 常用类库详解：字符串、集合、IO流与并发编程实战指南

核心摘要：Java 标准类库（API）是提升开发效率与代码质量的基石。本文深度解析 Java 常用类库的核心组件，涵盖 字符串处理、集合框架、日期时间 API、IO 流及并发编程。通过详实的代码示例与架构图解，帮助开发者全面掌握 Java 核心 API 的最佳实践，构建高性能、高可用的企业级应用。

4. 常用类库核心概述

Java 提供了丰富且强大的标准类库，极大地简化了底层开发过程。熟练掌握这些类库不仅能显著提高开发效率，还能有效保障代码的健壮性与可维护性。本章将系统性地剖析日常开发中最核心的类库模块，包括字符串处理、集合框架、日期时间处理、IO 流以及并发处理。

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

字符串在编程中无处不在。Java 提供了 String 类来表示不可变的字符串，同时提供了 StringBuilder 和 StringBuffer 类来处理可变字符串，以满足不同场景下的性能与线程安全需求。

4.1.1 String 类的不可变性与核心方法

String 对象一旦创建，其值就不能更改。这种不可变性使得 String 对象天生具备线程安全的特性，并且可以被安全地缓存和共享（如字符串常量池）。

String str = "Hello";
String str2 = new String("World");

// 字符串连接（底层会自动优化或使用 StringBuilder）
String str3 = str + " " + str2; // "Hello World"

// 常用核心方法
System.out.println(str.length());               // 5
System.out.println(str.charAt(0));              // 'H'
System.out.println(str.substring(1, 4));        // "ell"
System.out.println(str.equals("Hello"));        // true
System.out.println(str.equalsIgnoreCase("hello")); // true
System.out.println(str.indexOf("l"));           // 2
System.out.println(str.lastIndexOf("l"));       // 3
System.out.println(str.replace("l", "L"));      // "HeLLo"
System.out.println(str.toUpperCase());          // "HELLO"
System.out.println(str.toLowerCase());          // "hello"
System.out.println("  trim  ".trim());          // "trim"
System.out.println(String.valueOf(123));        // "123"

// 字符串分割
String str4 = "apple,banana,orange";
String[] fruits = str4.split(",");
for (String fruit : fruits) {
    System.out.println(fruit);
}
​

4.1.2 StringBuilder 与 StringBuffer 的高效拼接

StringBuilder 和 StringBuffer 用于创建和修改可变字符串，避免了频繁创建 String 对象带来的内存与性能开销。

// StringBuilder：非线程安全，单线程下性能最优
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.insert(5, ",");
sb.delete(5, 6);
sb.reverse();
System.out.println(sb.toString()); // dlroW olleH

// StringBuffer：线程安全，适用于多线程环境
StringBuffer sbf = new StringBuffer("Hello");
sbf.append(" World");
System.out.println(sbf.toString()); // Hello World
​

选型指南：String vs StringBuilder vs StringBuffer

类名	可变性	线程安全	性能	适用场景
String	不可变	安全	较低（频繁修改时）	字符串常量、少量修改操作
StringBuilder	可变	不安全	最高	单线程环境下的频繁字符串拼接
StringBuffer	可变	安全	中等	多线程环境下的频繁字符串拼接

4.2 集合框架 (java.util)：数据存储与操作的核心

Java 集合框架提供了一组高度优化的接口和类，用于存储、检索和操作对象集合。核心接口主要包括 List、Set、Map 以及 Queue。

4.2.1 List 接口：有序集合的灵活运用

List 是一个有序集合，允许存储重复元素。常用的实现类有 ArrayList 和 LinkedList。

• ArrayList：基于动态数组实现，随机访问（按索引查询）效率极高，但中间位置的插入和删除效率较低。
• LinkedList：基于双向链表实现，插入和删除效率高，但随机访问效率较低。

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

System.out.println(list.get(0)); // Apple
list.remove(1);
System.out.println(list.size()); // 2

List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);

System.out.println(linkedList.get(1)); // 2
linkedList.remove(1);
System.out.println(linkedList.size()); // 2
​

4.2.2 Set 接口：唯一性约束与去重机制

Set 是一个不允许存储重复元素的集合，常用于数据去重。

• HashSet：基于哈希表实现，无序，访问和插入速度极快。
• TreeSet：基于红黑树实现，元素按自然顺序或自定义比较器排序。

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 重复元素，不会被添加

System.out.println(set.size()); // 2
System.out.println(set.contains("Banana")); // true

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);

for (Integer i : treeSet) {
    System.out.println(i); // 按顺序输出 1, 2, 3
}
​

4.2.3 Map 接口：键值对映射与高效检索

Map 存储键值对（Key-Value），键（Key）不允许重复。

• HashMap：基于哈希表实现，无序，查询和插入时间复杂度接近 O(1)。
• TreeMap：基于红黑树实现，按键的自然顺序或自定义顺序排序。

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Orange", 3);

System.out.println(map.get("Banana")); // 2
System.out.println(map.containsKey("Apple")); // true
System.out.println(map.values()); // [1, 2, 3]
System.out.println(map.keySet()); // [Apple, Banana, Orange]

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Banana", 2);
treeMap.put("Apple", 1);
treeMap.put("Orange", 3);

for (String key : treeMap.keySet()) {
    System.out.println(key + ": " + treeMap.get(key)); // 按 Key 字母顺序输出
}
​

4.2.4 集合遍历与 Stream API 进阶

除了传统的迭代器（Iterator）和增强 for 循环，Java 8 引入的 Stream API 提供了更声明式的集合处理方式。

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

// 1. 使用迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

// 2. 使用增强 for 循环
for (String fruit : list) {
    System.out.println(fruit);
}

// 3. 使用 Java 8 Stream API (推荐用于复杂过滤与转换)
list.stream()
    .filter(fruit -> fruit.startsWith("A"))
    .map(String::toUpperCase)
    .forEach(System.out::println);
​

4.3 现代日期时间处理 (java.time)

Java 8 引入了全新的 java.time 包，彻底解决了旧版 java.util.Date 和 java.util.Calendar 存在的线程不安全、设计混乱及易用性差等痛点。新 API 采用不可变设计，天生支持线程安全。

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeExample {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate today = LocalDate.now();
        System.out.println("Today's Date: " + today);

        // 获取当前时间
        LocalTime now = LocalTime.now();
        System.out.println("Current Time: " + now);

        // 获取当前日期和时间
        LocalDateTime currentDateTime = LocalDateTime.now();
        System.out.println("Current Date and Time: " + currentDateTime);

        // 格式化日期和时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = currentDateTime.format(formatter);
        System.out.println("Formatted Date and Time: " + formattedDateTime);

        // 解析字符串为日期
        String dateString = "2023-10-27";
        LocalDate parsedDate = LocalDate.parse(dateString);
        System.out.println("Parsed Date: " + parsedDate);
    }
}
​

核心类库解析：

• LocalDate：表示日期（年、月、日），无时区信息。
• LocalTime：表示时间（时、分、秒、纳秒），无时区信息。
• LocalDateTime：表示日期和时间的组合。
• ZonedDateTime：包含时区信息的完整日期时间。
• DateTimeFormatter：线程安全的日期时间格式化与解析工具。
• Duration / Period：分别用于计算时间间隔（秒/纳秒级）和日期间隔（年/月/日级）。

4.4 IO 流与文件操作 (java.io & java.nio)

Java IO 流用于在程序与外部资源（如文件、网络）之间读取和写入数据。传统 IO 流分为字节流和字符流。

4.4.1 字节流 (Byte Stream)

字节流以字节（8 bit）为单位处理数据，适用于读写二进制文件（如图片、音频、视频）。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 使用 try-with-resources 自动关闭流
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

4.4.2 字符流 (Character Stream)

字符流以字符（16 bit Unicode）为单位处理数据，专为文本文件设计，能有效避免中文等多字节字符的乱码问题。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt");
             FileWriter fw = new FileWriter("output.txt")) {
            
            int data;
            while ((data = fr.read()) != -1) {
                fw.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

4.4.3 缓冲流与 NIO 进阶

缓冲流（如 BufferedReader）通过在内存中开辟缓冲区，大幅减少底层系统的 IO 调用次数，显著提升读写效率。对于高并发或大文件处理场景，建议进一步学习 Java NIO (New IO)，其提供的 Channel、Buffer 和 Selector 机制能实现非阻塞 IO，极大提升系统吞吐量。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine(); // 跨平台换行
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
​

4.5 并发编程与多线程处理 (java.util.concurrent)

Java 并发 API（JUC）提供了用于多线程编程的高级工具和类，极大简化了并发控制的复杂度。

4.5.1 Thread 类和 Runnable 接口

创建线程的基础方式包括继承 Thread 类或实现 Runnable 接口。在实际开发中，更推荐实现 Runnable 接口（或 Callable），以避免 Java 单继承的限制。

// 实现 Runnable 接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable thread is running");
    }
}

// 继承 Thread 类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        thread1.start();

        MyThread thread2 = new MyThread();
        thread2.start();
    }
}
​

4.5.2 线程池：ExecutorService 与 Future

直接创建和销毁线程开销较大。ExecutorService 提供了线程池管理机制，而 Future 接口用于获取异步计算的返回结果。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorServiceExample {
    public static void main(String[] args) throws Exception {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 提交 Callable 任务并获取 Future
        Future<String> future = executor.submit(() -> {
            Thread.sleep(2000);
            return "Task completed";
        });
        
        System.out.println("Task submitted");
        // 阻塞当前线程，直到异步任务完成并获取结果
        System.out.println("Result: " + future.get()); 
        
        // 优雅关闭线程池
        executor.shutdown();
    }
}
​

4.5.3 线程同步：Lock 接口与 synchronized

为了保证多线程环境下的数据一致性，必须使用同步机制。synchronized 是 JVM 层面的内置锁，而 Lock（如 ReentrantLock）提供了更灵活的 API 层锁机制。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保在 finally 块中释放锁
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) example.increment();
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) example.increment();
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final Count: " + example.getCount()); // 准确输出 20000
    }
}
​

总结与最佳实践建议

本文系统梳理了 Java 开发中最核心的常用类库，涵盖了从基础的字符串处理、复杂的集合框架，到现代的日期时间 API、底层的 IO 流以及高阶的并发编程。

核心最佳实践建议：

1. 优先使用现代 API：如使用 java.time 替代 Date，使用 StringBuilder 替代字符串加号拼接。
2. 合理选择数据结构：根据读写频率、是否需要排序、是否线程安全等维度，精准选择 List、Set 或 Map 的具体实现类。
3. 拥抱并发工具类：在生产环境中，优先使用 ExecutorService 线程池和 ConcurrentHashMap 等并发集合，避免手动管理线程和编写易错的同步代码。
4. 资源自动管理：始终使用 try-with-resources 语法来处理 IO 流和数据库连接，防止资源泄漏。

熟练掌握并灵活应用这些 Java 标准类库，是每一位开发者从“代码编写者”向“架构设计者”进阶的必经之路。建议结合实际业务场景，通过大量的代码重构与性能调优实践，不断深化对底层 API 运行机制的理解。