Java 8 Stream API 性能优化技巧 ⚡

1. 选择合适的数据源

// ✅ 优化：使用并行流处理大数据集
List<Integer> largeList = Arrays.asList(1, 2, 3, /*...很多数据...*/);
largeList.parallelStream()
    .filter(x -> x > 100)
    .collect(Collectors.toList());

// ❌ 避免：小数据集使用并行流（开销大于收益）
List<Integer> smallList = Arrays.asList(1, 2, 3);
smallList.stream() // 而不是 parallelStream()
    .filter(x -> x > 1)
    .collect(Collectors.toList());

2. 优化操作顺序

// ✅ 优化：先过滤再映射
list.stream()
    .filter(person -> person.getAge() > 18) // 减少后续操作的数据量
    .map(Person::getName)
    .collect(Collectors.toList());

// ❌ 低效：先映射再过滤
list.stream()
    .map(Person::getName)
    .filter(name -> name.length() > 3)
    .collect(Collectors.toList());

3. 使用原始类型流

// ✅ 优化：使用IntStream避免装箱拆箱
int sum = IntStream.range(1, 1000)
    .filter(x -> x % 2 == 0)
    .sum();

// ❌ 低效：使用包装类型
int sum = Stream.iterate(1, x -> x + 1)
    .limit(999)
    .filter(x -> x % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

4. 合理使用短路操作

// ✅ 优化：使用短路操作
boolean hasAdult = people.stream()
    .anyMatch(person -> person.getAge() >= 18); // 找到第一个就停止

Optional<Person> firstAdult = people.stream()
    .filter(person -> person.getAge() >= 18)
    .findFirst(); // 短路操作

5. 避免不必要的中间操作

// ✅ 优化：直接收集
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

// ❌ 低效：不必要的中间收集
List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList())
    .stream()
    .collect(Collectors.toList());

6. 选择合适的收集器

// ✅ 优化：使用专门的收集器
Map<String, List<Person>> groupByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));

// ✅ 优化：预设容量
Set<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toCollection(
        () -> new HashSet<>(people.size()))); // 预设容量避免扩容

7. 并行流的正确使用

// ✅ 适合并行的场景：计算密集型任务
List<Integer> result = largeNumbers.parallelStream()
    .filter(this::isPrime) // 计算密集
    .collect(Collectors.toList());

// ❌ 不适合并行：IO密集型任务
// 数据库查询、文件读写等应避免使用parallelStream

8. 使用预定义的收集器

// ✅ 优化：使用预定义收集器
String result = words.stream()
    .collect(Collectors.joining(", ")); // 预定义，性能更好

// ❌ 低效：手动reduce
String result = words.stream()
    .reduce("", (a, b) -> a + ", " + b);

9. 避免创建不必要的对象

// ✅ 优化：使用方法引用
list.stream()
    .map(String::toUpperCase) // 方法引用，更高效
    .collect(Collectors.toList());

// ❌ 低效：创建lambda表达式
list.stream()
    .map(s -> s.toUpperCase()) // 每次调用都创建新的lambda实例
    .collect(Collectors.toList());

10. 性能测试示例

// 性能对比工具方法
public class StreamPerformanceTest {
  
    public static void benchmarkOperation(String name, Runnable operation) {
        long start = System.nanoTime();
        operation.run();
        long end = System.nanoTime();
        System.out.println(name + ": " + (end - start) / 1_000_000 + " ms");
    }
  
    public static void main(String[] args) {
        List<Integer> numbers = IntStream.range(1, 1_000_000)
            .boxed()
            .collect(Collectors.toList());
          
        // 测试串行vs并行
        benchmarkOperation("Serial Stream", () -> {
            numbers.stream()
                .filter(x -> x % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();
        });
      
        benchmarkOperation("Parallel Stream", () -> {
            numbers.parallelStream()
                .filter(x -> x % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();
        });
    }
}

最佳实践总结 📋

1. 数据量小（<1000) → 使用串行流
2. 数据量大且CPU密集 → 考虑并行流
3. 优先过滤，后变换 → 减少处理元素数量
4. 使用原始类型流 → 避免装箱拆箱开销
5. 善用短路操作 → findFirst(), anyMatch() 等
6. 选择合适的收集器 → 避免手动reduce
7. 预设集合容量 → 减少扩容开销

记住：过早优化是万恶之源，先保证代码正确性，再根据实际性能瓶颈进行针对性优化！ 🎯

本文转自渣哥zha-ge.cn
本文转自渣哥zha-ge.cn