java stream readline Java使用指南：Stream的使用

java stream readline Java使用指南：Stream的使用

——从“怎么做”到“做什么”的思维转变

想象一下这个场景：你有一筐苹果，你需要筛选出红苹果，然后找出其中最大的一个。

传统方式（指令式编程）：

你可能会这样想：

创建一个空篮子（用来放红苹果）。我亲自一个个检查筐里的每个苹果（for 循环）。如果苹果是红色的（if 判断），就把它放到空篮子里。然后，我再遍历红苹果篮子，比较每个苹果的大小，记录下最大的那个。

这个过程很直观，但你详细地指挥了计算机每一个步骤。这就是“怎么做”（How）。

方式（声明式编程）：

现在，换一种思维方式。你对着这筐苹果说：

“我只要红苹果（声明需求），然后请帮我找出最大的那个（声明结果）。”

至于怎么遍历、怎么比较java stream readline Java使用指南：Stream的使用，你完全不关心，交给一个“流水线”自动完成。这就是“做什么”（What）。

就是这个“流水线”。它让你能够以声明性的方式处理数据集合（如 List、Set、Map）java stream readline，写出更简洁、可读、高效的代码。

流水线解剖课

一条完整的 流水线包含三个核心部分，就像一条工厂生产线：

1. 数据源（）

这是流水线的起点，即数据的来源。常见的有：

2. 中间操作（ ）

这是流水线上的“加工站”。关键点：中间操作是“懒惰”的，它们只是设定了规则，并不会立刻执行。 你可以串联多个中间操作。

3. 终端操作（ ）

这是流水线的“终点站”。只有终端操作被调用时，整个流水线才会被触发，开始真正处理数据。 执行后，流就被消耗掉了，不能再使用。

创建流的方法

1. 从集合创建

// 从List创建
List list = Arrays.asList("a", "b", "c");
Stream stream1 = list.stream();
// 并行流
Stream parallelStream = list.parallelStream();

2. 从数组创建

String[] array = {"a", "b", "c"};
Stream stream2 = Arrays.stream(array);
// 指定范围
Stream stream3 = Arrays.stream(array, 1, 3); // "b", "c"

3. 使用 静态方法

// 直接指定元素
Stream stream4 = Stream.of("a", "b", "c");
// 生成空流
Stream emptyStream = Stream.empty();
// 生成无限流：从种子开始，应用函数生成后续元素
Stream infinite1 = Stream.iterate(0, n -> n + 2); // 0, 2, 4, 6...
// 生成无限流：使用Supplier不断生成
Stream infinite2 = Stream.generate(Math::random);
// 生成有限流（Java 9+）
Stream finite = Stream.iterate(0, n -> n  n + 1); // 0到9

4. 原始类型流（避免装箱开销）

IntStream intStream = IntStream.range(1, 5);        // 1,2,3,4
IntStream intStreamClosed = IntStream.rangeClosed(1, 5); // 1,2,3,4,5
LongStream longStream = LongStream.range(1, 5);
DoubleStream doubleStream = DoubleStream.of(1.1, 2.2, 3.3);

中间操作方法

中间操作是”懒惰”的，它们只是设定规则，不会立即执行。

1. 过滤操作

() – 条件过滤

List words = Arrays.asList("apple", "banana", "cherry", "date");
List longWords = words.stream()
    .filter(word -> word.length() > 5)
    .collect(Collectors.toList());
// 结果: ["banana", "cherry"]

() – 去重

List numbers = Arrays.asList(1, 2, 2, 3, 3, 3);
List unique = numbers.stream()
    .distinct()
    .collect(Collectors.toList());
// 结果: [1, 2, 3]

2. 映射转换操作

map() – 一对一转换

List names = Arrays.asList("Alice", "Bob", "Charlie");
List nameLengths = names.stream()
    .map(String::length)  // 方法引用，等价于 .map(name -> name.length())
    .collect(Collectors.toList());
// 结果: [5, 3, 7]

(Function>) – 一对多转换并扁平化

List<List> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d", "e")
);
List flatList = listOfLists.stream()
    .flatMap(List::stream)  // 将每个List转换成Stream，然后合并
    .collect(Collectors.toList());
// 结果: ["a", "b", "c", "d", "e"]

(), (), () – 转换为原始类型流

List numbers = Arrays.asList("1", "2", "3");
IntStream intStream = numbers.stream()
    .mapToInt(Integer::parseInt);  // 避免装箱，性能更好

3. 排序和限制操作

() – 自然排序

List fruits = Arrays.asList("banana", "apple", "cherry");
List sortedFruits = fruits.stream()
    .sorted()
    .collect(Collectors.toList());
// 结果: ["apple", "banana", "cherry"]

() – 自定义排序

List fruits = Arrays.asList("banana", "apple", "cherry");
List sortedByLength = fruits.stream()
    .sorted(Comparator.comparing(String::length))
    .collect(Collectors.toList());
// 结果: ["apple", "banana", "cherry"] (按长度排序)

limit(long ) – 限制数量

Stream.iterate(1, n -> n + 1)
    .limit(5)
    .forEach(System.out::print);  // 输出: 12345

skip(long n) – 跳过前n个元素

Stream.of(1, 2, 3, 4, 5)
    .skip(2)
    .forEach(System.out::print);  // 输出: 345

4. 查看和调试操作

peek() – 查看流经的元素（主要用于调试）

List result = Stream.of("a", "b", "c")
    .peek(System.out::println)  // 打印每个元素
    .map(String::toUpperCase)
    .peek(System.out::println)  // 打印转换后的元素
    .collect(Collectors.toList());
// 输出: a A b B c C

终端操作方法

终端操作会触发流的执行，执行后流就被消耗了。

1. 遍历消费操作

() – 遍历每个元素

List names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
    .forEach(name -> System.out.println("Hello, " + name));

() – 保证顺序的遍历（在并行流中重要）

Stream.of("a", "b", "c")
    .parallel()
    .forEachOrdered(System.out::print);  // 保证输出顺序: abc

2. 收集操作

() – 最强大的收集操作

List list = stream.collect(Collectors.toList());
Set set = stream.collect(Collectors.toSet());
// 复杂收集示例
Map nameLengthMap = names.stream()
    .collect(Collectors.toMap(
        name -> name,           // key映射
        String::length          // value映射
    ));
// 分组
Map<Integer, List> groupByLength = names.stream()
    .collect(Collectors.groupingBy(String::length));
// 结果: {3=["Bob"], 5=["Alice"], 7=["Charlie"]}
// 连接字符串
String joined = names.stream()
    .collect(Collectors.joining(", ", "[", "]"));
// 结果: [Alice, Bob, Charlie]

3. 匹配检查操作

() – 是否存在满足条件的元素

boolean hasLongName = names.stream()
    .anyMatch(name -> name.length() > 10);  // 短路操作

() – 是否所有元素都满足条件

boolean allShortNames = names.stream()
    .allMatch(name -> name.length() < 10);

() – 是否没有元素满足条件

boolean noEmptyNames = names.stream()
    .noneMatch(String::isEmpty);

4. 查找操作

() – 返回第一个元素

Optional first = names.stream().findFirst();

() – 返回任意元素（在并行流中效率更高）

Optional any = names.parallelStream().findAny();

5. 统计计算操作

count() – 计数

long count = names.stream().count();

min() / max() – 最小/最大值

Optional shortest = names.stream()
    .min(Comparator.comparing(String::length));
Optional longest = names.stream()
    .max(Comparator.comparing(String::length));

6. 归约操作

– 将流归约为单个值

// 求和
Optional sum = Stream.of(1, 2, 3, 4)
    .reduce((a, b) -> a + b);  // 10
// 带初始值的归约
Integer sumWithIdentity = Stream.of(1, 2, 3, 4)
    .reduce(0, (a, b) -> a + b);  // 10
// 复杂的归约（用于并行流优化）
Integer complexSum = Stream.of(1, 2, 3, 4)
    .reduce(0,
            (a, b) -> a + b,          // 累加器
            (a, b) -> a + b);         // 组合器（并行时使用）

7. 原始类型流的特殊终端操作

IntStream intStream = IntStream.of(1, 2, 3, 4);
int sum = intStream.sum();           // 求和
OptionalDouble avg = intStream.average(); // 平均值
OptionalInt min = intStream.min();   // 最小值
OptionalInt max = intStream.max();   // 最大值
// 统计信息汇总
IntSummaryStatistics stats = intStream.summaryStatistics();
System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Min: " + stats.getMin());
System.out.println("Max: " + stats.getMax());
System.out.println("Average: " + stats.getAverage());

Java 提供了丰富的方法来处理数据，遵循”创建→转换→消费”的模式。关键要点：

中间操作是惰性的，只有终端操作才会触发执行流只能消费一次java stream readline，消费后不能重复使用优先使用方法引用让代码更简洁合理使用原始类型流提升性能并行流不是万能的java stream readlinejava stream readline Java使用指南：Stream的使用，要根据场景选择