JavaStreamAPI实战提升集合操作效率的5个核心技巧

### 1. 优先使用基本类型流

在处理数值计算时，避免装箱/拆箱开销。使用`IntStream`、`LongStream`、`DoubleStream`替代`Stream`等泛型流：

```java

// 低效做法

List numbers = Arrays.asList(1,2,3,4,5);

int sum = numbers.stream()

.mapToInt(Integer::intValue)

.sum();

// 高效做法

IntStream.rangeClosed(1, 100)

.filter(n -> n % 2 == 0)

.average();

```

### 2. 短路操作优化

利用`limit()`、`findFirst()`等短路操作提前终止流处理：

```java

// 找到第一个满足条件的元素立即返回

Optional result = list.stream()

.filter(s -> s.length() > 10)

.findFirst();

// 限制处理数量

List top5 = data.stream()

.sorted(Comparator.comparing(Data::getScore))

.limit(5)

.collect(Collectors.toList());

```

### 3. 避免中间状态重复计算

对需要多次使用的中间结果进行缓存：

```java

// 低效做法

List names = persons.stream()

.filter(p -> p.getAge() > 18)

.map(Person::getName)

.collect(Collectors.toList());

List addresses = persons.stream()

.filter(p -> p.getAge() > 18)

.map(Person::getAddress)

.collect(Collectors.toList());

// 高效做法

List adults = persons.stream()

.filter(p -> p.getAge() > 18)

.collect(Collectors.toList());

List names = adults.stream().map(Person::getName).collect(toList());

List addresses = adults.stream().map(Person::getAddress).collect(toList());

```

### 4. 并行流合理使用

在数据量大且可并行处理时使用并行流：

```java

// 顺序处理

List result = data.stream()

.map(this::expensiveOperation)

.collect(Collectors.toList());

// 并行处理（数据量>10000时效率提升明显）

List result = data.parallelStream()

.map(this::expensiveOperation)

.collect(Collectors.toList());

```

### 5. 选择高效的终端操作

根据需求选择最合适的收集器：

```java

// 需要保持顺序时

Map> byDept = employees.stream()

.collect(Collectors.groupingBy(Employee::getDepartment));

// 需要并发处理时

ConcurrentMap> byDept = employees.parallelStream()

.collect(Collectors.groupingByConcurrent(Employee::getDepartment));

// 简单拼接字符串

String joined = stream.collect(Collectors.joining(, ));

```