Java中大数据流处理的7大性能优化对比

// 问题：过度并行，线程池被耗尽
List<String> results = data.stream()
    .parallel()
    .map(item -> processItem(item)) // I/O密集型操作
    .collect(Collectors.toList());

// 解决方案：自定义线程池，针对I/O密集型
ExecutorService executor = Executors.newFixedThreadPool(20); // 20线程，I/O密集型建议2xCPU

List<String> results = data.stream()
    .parallel()
    .map(item -> {
        // 用自定义线程池执行I/O密集型操作
        return CompletableFuture.supplyAsync(() -> processItem(item), executor)
            .join();
    })
    .collect(Collectors.toList());

executor.shutdown(); // 别忘了关闭

List<String> results = data.stream()
    .map(item -> {
        // 每次循环都创建新对象
        User user = new User(item.getId(), item.getName());
        return user.getName();
    })
    .collect(Collectors.toList());

// 解决方案：复用对象，避免频繁创建
User user = new User(); // 复用对象

List<String> results = data.stream()
    .map(item -> {
        // 直接修改已有对象，避免new
        user.setId(item.getId());
        user.setName(item.getName());
        return user.getName();
    })
    .collect(Collectors.toList());

List<String> results = new ArrayList<>();
for (String item : data) {
    results.add(item); // ArrayList每次插入都可能扩容
}

// 解决方案：预分配容量，避免扩容
List<String> results = new ArrayList<>(data.size()); // 预分配容量

for (String item : data) {
    results.add(item); // 不再扩容
}

List<String> results = data.stream()
    .map(item -> {
        // 重复计算，浪费CPU
        int len = item.length();
        return item.substring(0, len / 2);
    })
    .collect(Collectors.toList());

List<String> results = data.stream()
    .map(item -> {
        // 提前计算长度，避免重复
        int len = item.length();
        return item.substring(0, len / 2);
    })
    .collect(Collectors.toList());

List<String> results = data.stream()
    .map(item -> {
        // 重复计算，浪费CPU
        return calculate(item) + calculate(item);
    })
    .collect(Collectors.toList());

List<String> results = data.stream()
    .map(item -> {
        // 缓存计算结果
        int result = calculate(item);
        return result + result;
    })
    .collect(Collectors.toList());

List<String> results = data.stream()
    .map(item -> {
        // 直接调用数据库，I/O阻塞
        return db.query(item.getId());
    })
    .collect(Collectors.toList());

// 解决方案：异步I/O，不阻塞线程
List<String> results = data.stream()
    .map(item -> CompletableFuture.supplyAsync(() -> db.query(item.getId())))
    .map(CompletableFuture::join)
    .collect(Collectors.toList());

List<String> results = data.stream()
    .filter(item -> {
        // O(n^2)算法，效率低
        for (String other : data) {
            if (item.equals(other)) {
                return true;
            }
        }
        return false;
    })
    .collect(Collectors.toList());

// 解决方案：用Set存储，O(1)查找
Set<String> dataSet = new HashSet<>(data);
List<String> results = data.stream()
    .filter(item -> dataSet.contains(item))
    .collect(Collectors.toList());