名称: java-streams-api 用户可调用: false 描述: 使用Java Streams API进行函数式风格的数据处理。当使用流处理集合时使用。允许工具:

Bash
Read
Write
Edit

Java流API

掌握Java的流API，用于集合的函数式操作，通过声明式数据处理，如过滤、映射和归约。

流简介

流提供了一种函数式方法处理对象集合。与集合不同，流不存储元素——它们通过操作管道从源传送元素。

创建流:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamCreation {
    public static void main(String[] args) {
        // 从集合
        List<String> list = Arrays.asList("a", "b", "c");
        Stream<String> stream1 = list.stream();

        // 从数组
        String[] array = {"a", "b", "c"};
        Stream<String> stream2 = Arrays.stream(array);

        // 使用Stream.of()
        Stream<String> stream3 = Stream.of("a", "b", "c");

        // 空流
        Stream<String> stream4 = Stream.empty();

        // 带限制的无限流
        Stream<Integer> stream5 = Stream.iterate(0, n -> n + 1)
                                       .limit(10);
    }
}

中间操作

中间操作返回新流且是惰性的——直到终端操作调用才执行。

filter() - 选择元素:

import java.util.List;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);

        // 过滤偶数
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        // 结果: [2, 4, 6, 8]

        // 可以链式多个过滤器
        List<Integer> result = numbers.stream()
            .filter(n -> n > 3)
            .filter(n -> n < 7)
            .collect(Collectors.toList());
        // 结果: [4, 5, 6]
    }
}

map() - 转换元素:

public class MapExample {
    public static void main(String[] args) {
        List<String> words = List.of("hello", "world");

        // 转换为大写
        List<String> uppercase = words.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        // 结果: ["HELLO", "WORLD"]

        // 获取字符串长度
        List<Integer> lengths = words.stream()
            .map(String::length)
            .collect(Collectors.toList());
        // 结果: [5, 5]

        // 链式转换
        List<Integer> doubled = List.of(1, 2, 3).stream()
            .map(n -> n * 2)
            .collect(Collectors.toList());
        // 结果: [2, 4, 6]
    }
}

flatMap() - 展平嵌套结构:

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<Integer>> nested = List.of(
            List.of(1, 2),
            List.of(3, 4),
            List.of(5, 6)
        );

        // 展平为单个列表
        List<Integer> flattened = nested.stream()
            .flatMap(List::stream)
            .collect(Collectors.toList());
        // 结果: [1, 2, 3, 4, 5, 6]

        // 分割字符串并展平
        List<String> sentences = List.of("hello world", "foo bar");
        List<String> words = sentences.stream()
            .flatMap(s -> Arrays.stream(s.split(" ")))
            .collect(Collectors.toList());
        // 结果: ["hello", "world", "foo", "bar"]
    }
}

distinct() 和 sorted():

public class DistinctSortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 2, 8, 2, 1, 5, 3);

        // 移除重复
        List<Integer> distinct = numbers.stream()
            .distinct()
            .collect(Collectors.toList());
        // 结果: [5, 2, 8, 1, 3]

        // 升序排序
        List<Integer> sorted = numbers.stream()
            .sorted()
            .collect(Collectors.toList());
        // 结果: [1, 2, 2, 3, 5, 5, 8]

        // 降序排序
        List<Integer> descending = numbers.stream()
            .sorted((a, b) -> b - a)
            .collect(Collectors.toList());

        // 去重并排序
        List<Integer> distinctSorted = numbers.stream()
            .distinct()
            .sorted()
            .collect(Collectors.toList());
        // 结果: [1, 2, 3, 5, 8]
    }
}

peek() - 调试或执行副作用:

public class PeekExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 调试流管道
        List<Integer> result = numbers.stream()
            .peek(n -> System.out.println("原始: " + n))
            .map(n -> n * 2)
            .peek(n -> System.out.println("加倍: " + n))
            .filter(n -> n > 5)
            .peek(n -> System.out.println("过滤: " + n))
            .collect(Collectors.toList());
    }
}

终端操作

终端操作产生结果或副作用并关闭流。

collect() - 收集结果:

import java.util.stream.Collectors;
import java.util.Map;
import java.util.Set;

public class CollectExample {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "cherry");

        // 到列表
        List<String> list = words.stream()
            .collect(Collectors.toList());

        // 到集合
        Set<String> set = words.stream()
            .collect(Collectors.toSet());

        // 到映射
        Map<String, Integer> map = words.stream()
            .collect(Collectors.toMap(
                w -> w,              // 键
                String::length       // 值
            ));
        // 结果: {apple=5, banana=6, cherry=6}

        // 连接字符串
        String joined = words.stream()
            .collect(Collectors.joining(", "));
        // 结果: "apple, banana, cherry"

        // 按长度分组
        Map<Integer, List<String>> grouped = words.stream()
            .collect(Collectors.groupingBy(String::length));
        // 结果: {5=[apple], 6=[banana, cherry]}
    }
}

reduce() - 合并元素:

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 带标识的和
        int sum = numbers.stream()
            .reduce(0, (a, b) -> a + b);
        // 结果: 15

        // 积
        int product = numbers.stream()
            .reduce(1, (a, b) -> a * b);
        // 结果: 120

        // 最大值
        Optional<Integer> max = numbers.stream()
            .reduce((a, b) -> a > b ? a : b);
        // 结果: Optional[5]

        // 使用方法引用
        int sum2 = numbers.stream()
            .reduce(0, Integer::sum);

        // 字符串连接
        String concatenated = List.of("a", "b", "c").stream()
            .reduce("", (a, b) -> a + b);
        // 结果: "abc"
    }
}

forEach() 和 forEachOrdered():

public class ForEachExample {
    public static void main(String[] args) {
        List<String> words = List.of("hello", "world");

        // 打印每个元素
        words.stream()
            .forEach(System.out::println);

        // 并行流有序迭代
        words.parallelStream()
            .forEachOrdered(System.out::println);

        // 带副作用（谨慎使用）
        List<String> results = new ArrayList<>();
        words.stream()
            .map(String::toUpperCase)
            .forEach(results::add);
    }
}

count(), anyMatch(), allMatch(), noneMatch():

public class MatchingExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 计数元素
        long count = numbers.stream()
            .filter(n -> n > 2)
            .count();
        // 结果: 3

        // 检查是否有匹配
        boolean hasEven = numbers.stream()
            .anyMatch(n -> n % 2 == 0);
        // 结果: true

        // 检查是否所有匹配
        boolean allPositive = numbers.stream()
            .allMatch(n -> n > 0);
        // 结果: true

        // 检查是否无匹配
        boolean noNegative = numbers.stream()
            .noneMatch(n -> n < 0);
        // 结果: true
    }
}

findFirst() 和 findAny():

public class FindExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 查找第一个元素
        Optional<Integer> first = numbers.stream()
            .filter(n -> n > 2)
            .findFirst();
        // 结果: Optional[3]

        // 查找任何（并行流中有用）
        Optional<Integer> any = numbers.parallelStream()
            .filter(n -> n > 2)
            .findAny();
        // 结果: Optional[3] 或 Optional[4] 或 Optional[5]

        // 处理空结果
        Integer value = numbers.stream()
            .filter(n -> n > 10)
            .findFirst()
            .orElse(-1);
        // 结果: -1
    }
}

高级收集器

分区和分组:

public class AdvancedCollectors {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

        // 按谓词分区
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        // 结果: {false=[1,3,5], true=[2,4,6]}

        // 带计数的分组
        Map<Integer, Long> lengthCounts = List.of("a", "bb", "ccc").stream()
            .collect(Collectors.groupingBy(
                String::length,
                Collectors.counting()
            ));
        // 结果: {1=1, 2=1, 3=1}

        // 下游收集器
        Map<Integer, List<String>> grouped =
            List.of("apple", "apricot", "banana").stream()
            .collect(Collectors.groupingBy(
                String::length,
                Collectors.mapping(
                    String::toUpperCase,
                    Collectors.toList()
                )
            ));
        // 结果: {5=[APPLE], 6=[BANANA], 7=[APRICOT]}
    }
}

统计收集器:

import java.util.IntSummaryStatistics;
import java.util.stream.Collectors;

public class StatisticsExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 汇总统计
        IntSummaryStatistics stats = numbers.stream()
            .collect(Collectors.summarizingInt(Integer::intValue));

        System.out.println("计数: " + stats.getCount());     // 5
        System.out.println("和: " + stats.getSum());         // 15
        System.out.println("最小值: " + stats.getMin());         // 1
        System.out.println("最大值: " + stats.getMax());         // 5
        System.out.println("平均值: " + stats.getAverage()); // 3.0

        // 平均
        double average = numbers.stream()
            .collect(Collectors.averagingInt(Integer::intValue));
        // 结果: 3.0
    }
}

并行流

并行流自动分区数据并并行处理。

使用并行流:

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);

        // 转换为并行流
        int sum = numbers.parallelStream()
            .filter(n -> n % 2 == 0)
            .mapToInt(Integer::intValue)
            .sum();

        // 从顺序到并行
        long count = numbers.stream()
            .parallel()
            .filter(n -> n > 3)
            .count();

        // 检查是否并行
        boolean isParallel = numbers.parallelStream().isParallel();
        // 结果: true

        // 回到顺序
        List<Integer> result = numbers.parallelStream()
            .sequential()
            .collect(Collectors.toList());
    }
}

性能考虑:

import java.util.stream.IntStream;

public class ParallelPerformance {
    public static void main(String[] args) {
        // 小数据集 - 顺序更快
        List<Integer> small = IntStream.range(0, 100)
            .boxed()
            .collect(Collectors.toList());

        // 大数据集 - 并行可能更快
        List<Integer> large = IntStream.range(0, 1_000_000)
            .boxed()
            .collect(Collectors.toList());

        // 顺序
        long start = System.nanoTime();
        long sum1 = large.stream()
            .mapToLong(Integer::longValue)
            .sum();
        long sequential = System.nanoTime() - start;

        // 并行
        start = System.nanoTime();
        long sum2 = large.parallelStream()
            .mapToLong(Integer::longValue)
            .sum();
        long parallel = System.nanoTime() - start;

        System.out.println("顺序: " + sequential);
        System.out.println("并行: " + parallel);
    }
}

原始流

专用原始类型流避免装箱开销。

IntStream, LongStream, DoubleStream:

import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.DoubleStream;

public class PrimitiveStreams {
    public static void main(String[] args) {
        // IntStream范围
        IntStream.range(1, 5)
            .forEach(System.out::println); // 1, 2, 3, 4

        // IntStream rangeClosed（包含）
        IntStream.rangeClosed(1, 5)
            .forEach(System.out::println); // 1, 2, 3, 4, 5

        // IntStream的和
        int sum = IntStream.of(1, 2, 3, 4, 5).sum();
        // 结果: 15

        // 平均
        double avg = IntStream.of(1, 2, 3, 4, 5)
            .average()
            .orElse(0.0);
        // 结果: 3.0

        // mapToInt避免装箱
        int total = List.of(1, 2, 3, 4, 5).stream()
            .mapToInt(Integer::intValue)
            .sum();

        // 生成随机数
        DoubleStream.generate(Math::random)
            .limit(5)
            .forEach(System.out::println);
    }
}

实际示例

处理业务对象:

class Employee {
    private String name;
    private String department;
    private double salary;

    public Employee(String name, String department, double salary) {
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    // 获取器
    public String getName() { return name; }
    public String getDepartment() { return department; }
    public double getSalary() { return salary; }
}

public class EmployeeProcessing {
    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee("Alice", "Engineering", 80000),
            new Employee("Bob", "Engineering", 90000),
            new Employee("Charlie", "Sales", 70000),
            new Employee("Diana", "Sales", 75000)
        );

        // 按部门平均工资
        Map<String, Double> avgSalaryByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.averagingDouble(Employee::getSalary)
            ));
        // 结果: {Engineering=85000.0, Sales=72500.0}

        // 最高薪员工
        Optional<Employee> highestPaid = employees.stream()
            .max((e1, e2) -> Double.compare(e1.getSalary(),
                                            e2.getSalary()));

        // 按部门总工资
        Map<String, Double> totalByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.summingDouble(Employee::getSalary)
            ));

        // 薪资超过75k的员工
        List<String> highEarners = employees.stream()
            .filter(e -> e.getSalary() > 75000)
            .map(Employee::getName)
            .collect(Collectors.toList());
    }
}

文件处理示例:

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class FileProcessing {
    public static void main(String[] args) throws IOException {
        // 以流读取文件行
        Files.lines(Paths.get("data.txt"))
            .filter(line -> !line.isEmpty())
            .map(String::trim)
            .forEach(System.out::println);

        // 统计文件单词数
        long wordCount = Files.lines(Paths.get("data.txt"))
            .flatMap(line -> Arrays.stream(line.split("\\s+")))
            .count();

        // 查找唯一单词
        Set<String> uniqueWords = Files.lines(Paths.get("data.txt"))
            .flatMap(line -> Arrays.stream(line.split("\\s+")))
            .map(String::toLowerCase)
            .collect(Collectors.toSet());
    }
}

何时使用此技能

使用java-streams-api当您需要时：

使用函数式操作处理集合
声明式过滤、映射或转换数据
聚合或归约集合为单个值
按条件分组或分区数据
链式多个数据转换
并行处理大数据集
编写更可读的集合处理代码
避免显式循环和可变状态
执行惰性操作评估
高效处理无限序列

最佳实践

可能时使用方法引用以提高可读性
避免在流操作中产生副作用
关闭I/O源的流（Files.lines等）
优先使用collect()而非forEach()进行累积
使用原始流避免装箱开销
保持流管道可读性，适当格式化
仅对大数据集使用并行流
不要重用流——它们是一次性的
在结果中优先使用Optional而非空检查
使用Collectors工厂方法进行常见操作

常见陷阱

终端操作后重用流（抛出异常）
流处理期间修改源集合
小数据集使用并行流（开销成本高）
无状态操作中的副作用（结果不可预测）
未正确处理Optional结果
链式过度使代码不可读
忘记关闭I/O源的流
当collect()更合适时使用forEach()
并行流中未考虑线程安全
不必要的装箱/拆箱导致的性能问题

Java流APISkill java-streams-api