Java核心类库详解：从String到并发工具

1. Java常用类概述

在Java开发中，常用类就像工具箱里的基础工具，是每个Java程序员必须熟练掌握的核心知识。我从业十多年来，发现90%的日常开发工作都围绕着这些基础类展开。String处理字符串、ArrayList管理集合、Date处理时间...这些类看似简单，但真正用好它们需要深入理解其设计原理和使用场景。

2. 核心常用类解析

2.1 String与StringBuilder

String类可能是Java中使用频率最高的类。但很多新手不知道的是，String对象是不可变的（immutable）。这意味着每次字符串拼接都会产生新对象：

java复制String str = "Hello";
str += " World"; // 实际上创建了新的String对象

对于频繁修改字符串的场景，应该使用StringBuilder。它的内部使用可变字符数组，避免了不必要的对象创建：

java复制StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World"); // 更高效

经验：在循环体内拼接字符串时，务必使用StringBuilder，否则可能引发严重的性能问题。

2.2 集合框架

Java集合框架包含在java.util包中，主要分为三类：

1. List：有序集合

   • ArrayList：基于动态数组，随机访问快
   • LinkedList：基于链表，插入删除快

2. Set：不重复集合

   • HashSet：基于哈希表
   • TreeSet：基于红黑树，保持排序

3. Map：键值对映射

   • HashMap：最常用的Map实现
   • TreeMap：保持键的排序

java复制// 典型用法示例
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.get("apple"); // 返回1

2.3 日期时间处理

Java 8引入了全新的日期时间API（java.time包），解决了旧Date类的诸多问题：

java复制LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
Duration duration = Duration.between(startTime, endTime);

新API的优势：

• 不可变对象，线程安全
• 更清晰的类设计（LocalDate、LocalTime分离）
• 更好的时区支持

3. 实用工具类

3.1 Arrays和Collections

这两个工具类提供了各种静态方法来操作数组和集合：

java复制int[] numbers = {3,1,4,2};
Arrays.sort(numbers); // 排序

List<Integer> list = new ArrayList<>();
Collections.sort(list); // 集合排序
Collections.reverse(list); // 反转

3.2 Objects类

Java 7引入的Objects类包含各种对象操作的工具方法：

java复制Objects.equals(a, b); // 安全的null比较
Objects.requireNonNull(obj); // 非空检查

3.3 Math和Random

Math类提供基本的数学运算：

java复制Math.max(a, b);
Math.sqrt(x);

Random类用于生成随机数：

java复制Random random = new Random();
int num = random.nextInt(100); // 0-99随机数

4. 文件IO相关类

4.1 File类

File类代表文件系统中的文件或目录：

java复制File file = new File("test.txt");
boolean exists = file.exists();
long size = file.length();

4.2 流类体系

Java IO流分为字节流和字符流：

1. 字节流：InputStream/OutputStream

   • FileInputStream/FileOutputStream
   • BufferedInputStream/BufferedOutputStream

2. 字符流：Reader/Writer

   • FileReader/FileWriter
   • BufferedReader/BufferedWriter

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

注意：务必使用try-with-resources确保流正确关闭，避免资源泄漏。

5. 异常处理类

Java异常体系以Throwable为基类，主要分为：

1. Error：系统级错误（如OutOfMemoryError）
2. Exception：可处理的异常
   • RuntimeException：未检查异常
   • 其他Exception：检查异常

常见异常类：

• NullPointerException
• ArrayIndexOutOfBoundsException
• IOException
• ClassCastException

java复制try {
    // 可能抛出异常的代码
} catch (IOException e) {
    // 处理特定异常
    logger.error("IO错误", e);
} catch (Exception e) {
    // 通用异常处理
    logger.error("发生错误", e);
} finally {
    // 清理资源
}

6. 多线程相关类

6.1 Thread和Runnable

创建线程的两种基本方式：

java复制// 方式1：继承Thread
class MyThread extends Thread {
    public void run() {
        // 线程逻辑
    }
}

// 方式2：实现Runnable
class MyTask implements Runnable {
    public void run() {
        // 线程逻辑
    }
}

// 使用
new MyThread().start();
new Thread(new MyTask()).start();

6.2 并发工具类

Java 5+提供了更强大的并发工具：

1. Executor框架

   java复制ExecutorService executor = Executors.newFixedThreadPool(4);
   executor.submit(() -> {
       // 任务代码
   });
   executor.shutdown();
   

2. 同步工具

   • CountDownLatch
   • CyclicBarrier
   • Semaphore

3. 并发集合

   • ConcurrentHashMap
   • CopyOnWriteArrayList

7. 反射相关类

反射API（java.lang.reflect）允许程序在运行时检查类信息：

java复制Class<?> clazz = Class.forName("java.lang.String");
Method[] methods = clazz.getMethods();
Field[] fields = clazz.getFields();

反射的典型用途：

• 动态加载类
• 框架中自动装配
• 测试工具

警告：反射会破坏封装性并影响性能，应谨慎使用。

8. 注解相关类

Java注解（Annotation）是一种元数据形式：

java复制@Override
@Deprecated
@SuppressWarnings("unchecked")

自定义注解：

java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
}

9. 泛型相关类

泛型提供了编译时类型安全检查：

java复制List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // 无需强制转换

通配符使用：

java复制// 上界通配符
List<? extends Number> numbers;

// 下界通配符
List<? super Integer> integers;

10. 函数式接口

Java 8引入的函数式编程支持：

java复制@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}

MyFunction add = (a, b) -> a + b;
int result = add.apply(2, 3); // 5

常用内置函数式接口：

• Predicate
• Function<T,R>
• Consumer
• Supplier

11. 最佳实践与性能优化

1. 字符串处理：

   • 优先使用StringBuilder进行多次修改
   • 使用String.intern()减少内存占用（谨慎）

2. 集合使用：

   • 预估容量初始化集合（如new ArrayList<>(100)）
   • 遍历HashMap使用entrySet()而非keySet()

3. 异常处理：

   • 不要吞掉异常（空的catch块）
   • 使用特定异常而非通用的Exception

4. 资源管理：

   • 总是使用try-with-resources
   • 及时关闭数据库连接、文件流等

12. 常见面试问题解析

1. String、StringBuilder和StringBuffer的区别？

   • String不可变，线程安全
   • StringBuilder可变，非线程安全
   • StringBuffer可变，线程安全（同步方法）

2. ArrayList和LinkedList的区别？

   • ArrayList基于数组，随机访问O(1)
   • LinkedList基于链表，插入删除O(1)

3. HashMap的工作原理？

   • 基于哈希表（数组+链表/红黑树）
   • 使用hashCode()和equals()方法
   • 负载因子默认0.75

4. Java 8新特性？

   • Lambda表达式
   • Stream API
   • 新的日期时间API
   • 默认方法

5. 如何避免内存泄漏？

   • 及时清除无用的集合引用
   • 正确关闭资源
   • 使用WeakReference处理缓存

13. 实际项目中的应用案例

13.1 日志处理系统

使用StringBuilder构建日志消息：

java复制public String buildLogMessage(String user, String action) {
    StringBuilder sb = new StringBuilder(128); // 预分配大小
    sb.append("[")
      .append(LocalDateTime.now())
      .append("] User ")
      .append(user)
      .append(" performed ")
      .append(action);
    return sb.toString();
}

13.2 缓存实现

使用ConcurrentHashMap构建线程安全的缓存：

java复制public class SimpleCache<K, V> {
    private final ConcurrentHashMap<K, V> map = new ConcurrentHashMap<>();
    
    public V get(K key) {
        return map.get(key);
    }
    
    public void put(K key, V value) {
        map.put(key, value);
    }
}

13.3 配置文件读取

使用Properties类读取配置文件：

java复制Properties props = new Properties();
try (InputStream in = Files.newInputStream(Paths.get("config.properties"))) {
    props.load(in);
    String value = props.getProperty("key");
}

14. 调试与问题排查技巧

1. 字符串问题：

   • 使用equals()而非==比较内容
   • 注意字符串编码问题

2. 集合问题：

   • 检查ConcurrentModificationException
   • 注意集合的线程安全性

3. 日期问题：

   • 明确时区设置
   • 新旧API不要混用

4. 内存问题：

   • 使用VisualVM分析内存使用
   • 检查集合是否过度增长

5. 多线程问题：

   • 使用Thread.currentThread().getName()调试
   • 检查死锁和竞态条件

15. 版本兼容性注意事项

1. Java 8+：

   • 新的日期时间API
   • Lambda表达式
   • Stream API

2. Java 11+：

   • var局部变量类型推断
   • 新的HTTP Client

3. Java 17+：

   • 密封类（sealed class）
   • 模式匹配增强

重要：生产环境应明确指定-source和-target版本，避免兼容性问题。

16. 性能对比与基准测试

使用JMH进行微基准测试：

java复制@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class StringBenchmark {
    
    @Benchmark
    public String testStringConcat() {
        String result = "";
        for (int i = 0; i < 100; i++) {
            result += i;
        }
        return result;
    }
    
    @Benchmark
    public String testStringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            sb.append(i);
        }
        return sb.toString();
    }
}

典型性能结论：

• StringBuilder比String拼接快10-100倍
• ArrayList随机访问比LinkedList快100倍
• HashMap查找比TreeMap快（无排序需求时）

17. 扩展学习资源推荐

1. 官方文档：

   • Java SE API文档
   • Java语言规范

2. 书籍：

   • 《Effective Java》
   • 《Java并发编程实战》

3. 在线资源：

   • Oracle官方教程
   • Baeldung Java系列
   • Stack Overflow Java标签

4. 实践平台：

   • LeetCode Java题库
   • Codewars Java练习

18. 个人经验分享

在我多年的Java开发经历中，有几点深刻体会：

1. 基础类的熟练掌握能极大提升开发效率。看似简单的String或ArrayList，深入理解其实现原理后，能避免很多性能陷阱。

2. Java标准库在不断进化。比如从旧的Date到新的java.time，从同步集合到并发集合，及时跟进新特性很重要。

3. 工具类的合理使用能让代码更简洁。比如Objects.equals()替代手动的null检查，Collections.emptyList()返回不可变空集合等。

4. 多线程环境下要特别注意类的线程安全性。比如StringBuilder是非线程安全的，多线程环境应该用StringBuffer。

5. 资源管理是Java开发中最容易出错的地方之一。我强烈建议在任何情况下都使用try-with-resources，这是Java 7最实用的改进之一。

最后一个小技巧：在IDE中设置代码模板，快速生成常用代码片段，比如try-with-resources块、单元测试方法等，可以显著提高编码效率。