Java代码级性能优化

代码级优化从细节入手，减少不必要的资源消耗。

字符串优化

避免频繁创建字符串

// 不推荐：每次循环创建新字符串
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;  // 每次创建新对象
}

// 推荐：使用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

字符串常量池

// 推荐：使用字面量，利用常量池
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);  // true

// 不推荐：new创建，不走常量池
String s3 = new String("hello");
System.out.println(s1 == s3);  // false

// 推荐：intern()放入常量池
String s4 = s3.intern();
System.out.println(s1 == s4);  // true

集合优化

选择合适的集合

集合初始化大小

// 不推荐：默认容量，频繁扩容
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
    list.add("item");  // 多次扩容
}

// 推荐：预估大小
List<String> list = new ArrayList<>(10000);

// HashMap同理
Map<String, Object> map = new HashMap<>(1000);  // 避免扩容

遍历优化

// 不推荐：索引遍历LinkedList
LinkedList<String> list = new LinkedList<>();
for (int i = 0; i < list.size(); i++) {
    list.get(i);  // O(n)每次
}

// 推荐：迭代器遍历
for (String item : list) {
    // O(1)每次
}

// 推荐：forEach（Java 8+）
list.forEach(System.out::println);

循环优化

减少循环内计算

// 不推荐：循环内重复计算
for (int i = 0; i < list.size(); i++) {  // size()每次调用
    // ...
}

// 推荐：提取到循环外
int size = list.size();
for (int i = 0; i < size; i++) {
    // ...
}

// 推荐：增强for循环
for (Item item : list) {
    // ...
}

循环内避免创建对象

// 不推荐：每次创建
for (int i = 0; i < 10000; i++) {
    Date date = new Date();  // 每次创建
}

// 推荐：复用对象
Date date = new Date();
for (int i = 0; i < 10000; i++) {
    date.setTime(System.currentTimeMillis());
}

方法优化

方法参数优化

// 不推荐：可变参数（性能较低）
public void process(String... args) { }

// 推荐：明确参数
public void process(String arg1, String arg2) { }

// 推荐：批量处理
public void process(List<String> args) { }

避免过度封装

// 不推荐：过度封装
public int getValue() {
    return calculateValue();
}
private int calculateValue() {
    return fetchFromDB();
}
private int fetchFromDB() {
    return query();
}

// 推荐：直接处理
public int getValue() {
    return query();
}

对象创建优化

遏制对象创建

// 不推荐：频繁创建
public boolean isValid(String value) {
    return new Validator().validate(value);  // 每次创建
}

// 推荐：复用对象
private Validator validator = new Validator();
public boolean isValid(String value) {
    return validator.validate(value);
}

// 推荐：静态方法
public static boolean isValid(String value) {
    return Validator.validate(value);
}

对象池

// 大对象复用
public class ObjectPool {
    private Queue<BigObject> pool = new ConcurrentLinkedQueue<>();

    public BigObject borrow() {
        BigObject obj = pool.poll();
        return obj != null ? obj : new BigObject();
    }

    public void release(BigObject obj) {
        obj.reset();
        pool.offer(obj);
    }
}

异常处理优化

避免异常用于流程控制

// 不推荐：异常控制流程
public boolean exists(String key) {
    try {
        map.get(key);
        return true;
    } catch (NullPointerException e) {
        return false;
    }
}

// 推荐：正常判断
public boolean exists(String key) {
    return map.containsKey(key);
}

异常信息简洁

// 不推荐：异常信息过长
throw new Exception("详细错误信息...几百字...");

// 推荐：简洁信息
throw new Exception("参数无效: " + paramName);

Stream优化

合理使用Stream

// 简单操作：传统方式更快
List<String> names = new ArrayList<>();
for (User user : users) {
    names.add(user.getName());
}

// 复杂操作：Stream更清晰
List<String> names = users.stream()
    .filter(u -> u.isActive())
    .map(User::getName)
    .sorted()
    .collect(Collectors.toList());

// 并行Stream（大数据量）
List<String> names = users.parallelStream()
    .filter(u -> u.isActive())
    .map(User::getName)
    .collect(Collectors.toList());

Stream避免短路

// 不推荐：多次遍历
long count = users.stream().filter(u -> u.isActive()).count();
List<String> names = users.stream()
    .filter(u -> u.isActive())
    .map(User::getName)
    .collect(Collectors.toList());

// 推荐：一次遍历完成多个操作
Map<Boolean, List<User>> partitioned = users.stream()
    .collect(Collectors.partitioningBy(u -> u.isActive()));

缓存优化

本地缓存

// 简单缓存
private Map<String, Result> cache = new ConcurrentHashMap<>();

public Result compute(String key) {
    return cache.computeIfAbsent(key, k -> expensiveCompute(k));
}

// Guava缓存
LoadingCache<String, Result> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(CacheLoader.from(this::expensiveCompute));

代码优化原则

1. 先测量再优化：用JProfiler/Arthas找出热点
2. 优化关键路径：关注高频调用代码
3. 避免过度优化：可读性也很重要
4. 权衡取舍：内存vs速度、复杂vs简洁

注意事项

StringBuilder适合循环拼接，简单拼接用+即可

集合初始化大小避免扩容开销

对象复用适合大对象或高频创建

Stream适合复杂操作，简单操作传统方式更优

缓存需考虑内存占用和失效策略

要点总结

1. 字符串拼接用StringBuilder，常量池复用字符串
2. 集合预设大小避免扩容，选择合适类型
3. 循环外提取计算，循环内避免创建对象
4. 避免异常控制流程，复用对象减少创建
5. Stream适合复杂操作，缓存减少重复计算