Java Stream API 总结

Java Stream API 介绍

Java Stream API 是 Java 8 引入的一个功能强大的新库，它提供了一种高效且易于使用的处理数据的方式。Stream API 可以用来执行复杂的数据处理操作，比如过滤、映射、排序和聚合等。它主要用于集合对象，允许以声明方式处理数据，使代码更简洁、更易读，同时可以充分利用现代多核架构进行并行处理。

Stream 分类

Java 的 Stream 按照执行模式分类有：

顺序流：按照元素在集合中的顺序依次处理元素的流。
并行流：利用多核处理器并行处理元素的流。它将数据分成多个小块，分配给不同的线程进行处理，然后将结果合并。
无限流：可以生成无限个元素的流。可以通过特定的方法（如 iterate 和 generate）创建无限流。

按照数据类型分类有：

普通流：处理对象引用的流。
原始数据流：
- IntStream：处理 int 类型的流。
- LongStream：处理 long 类型的流。
- DoubleStream：处理 double 类型的流。

顺序流（Sequential Stream）

顺序流是按照元素在集合中的顺序依次处理元素的流。

特点：

处理元素的顺序与原始集合中元素的顺序一致。
通常适用于单个线程的顺序执行，不涉及并行处理。

示例：

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

public class StreamExamples {
   public static void main(String[] args) {
	   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
	   List<Integer> doubledNumbersSequential = numbers.stream()
			.map(n -> n * 2)
			.collect(Collectors.toList());
	   System.out.println(doubledNumbersSequential); // [2, 4, 6, 8, 10]
   }
}

并行流（Parallel Stream）

并行流是利用多核处理器并行处理元素的流。它将数据分成多个小块，分配给不同的线程进行处理，然后将结果合并。

特点：

可以提高处理大数据集的性能，特别是在多核处理器上。
处理元素的顺序可能与原始集合中的顺序不一致，除非进行特殊的排序操作。
需要注意线程安全问题，特别是在对共享数据进行修改时。

示例：

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

public class StreamExamples {
   public static void main(String[] args) {
	   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
	   List<Integer> doubledNumbersParallel = numbers.parallelStream()
			.map(n -> n * 2)
			.collect(Collectors.toList());
	   System.out.println(doubledNumbersParallel); // [2, 4, 6, 8, 10]
   }
}

无限流（Infinite Stream）

特点：

需要谨慎使用，因为无限流可能会导致程序无限循环，除非有适当的终止条件。
可以用于生成特定模式的序列或进行一些需要无限迭代的操作。

示例：

import java.util.stream.Stream;

public class StreamExamples {
   public static void main(String[] args) {
	   // 使用 iterate 创建无限流
	   Stream.iterate(0, n -> n + 2)
			.limit(10)
			.forEach(System.out::println);
	   // 使用 generate 创建无限流
	   Stream.generate(Math::random)
			.limit(5)
			.forEach(System.out::println);
   }
}

常用的 Stream 操作

创建 Stream

从集合创建流

从集合创建顺序 Stream

List<String> list = Arrays.asList("a", "b", "c", "d", "e");
Stream<String> stream = list.stream();

从集合创建并行 Stream

List<String> list = Arrays.asList("a", "b", "c", "d", "e");
Stream<String> parallelStream = list.parallelStream();

从数组创建 Stream

使用 Arrays.stream() 创建 Stream

int[] intArray = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(intArray);

String[] stringArray = {"a", "b", "c"};
Stream<String> stringStream = Arrays.stream(stringArray);

使用 Stream.of() 创建 Stream

Integer[] intArray = {1, 2, 3, 4, 5};
Stream<Integer> intStream = Stream.of(intArray);

String[] stringArray = {"a", "b", "c"};
Stream<String> stringStream = Stream.of(stringArray);

Stream.of() 除了可以根据数组创建 Stream 外，还可以根据可变参数创建 Stream

Stream<Integer> intStream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stringStream = Stream.of("a", "b", "c");

使用 Stream.ofNullable() 创建 Stream

Stream.ofNullable() 是 Java 9 引入的一种方法，用于创建一个包含单个元素的流，如果该元素为 null，则创建一个空流。

String str = "Hello, World!";
Stream<String> stream = Stream.ofNullable(str);
stream.forEach(System.out::println);  // Hello, World!

// 如果 str 是 null
str = null;
stream = Stream.ofNullable(str);
System.out.println("流中的元素个数: " + stream.count());  // 流中的元素个数: 0

创建无限流

使用 Stream.generate() 创建无限流

Stream.generate() 方法是一个静态方法，用于创建无限顺序流。在 Java 8 中引入的 Stream API 提供了一种声明性方式来处理集合和其他数据源。

基本语法

Stream<T> generate(Supplier<T> s)

Supplier<T> s：这是一个函数式接口，提供元素生成的逻辑。每次需要流中的新元素时，都会调用这个 Supplier 并将其结果添加到流中。

特点

无限流: generate() 创建的流是无限的，因为它没有终止条件。通常，这样的流需要通过限制操作（如 limit()）来限制大小，否则流的处理将无限进行下去。
懒加载: 像所有流操作一样，generate() 方法是惰性的。在终端操作（如 collect(), forEach()）被调用之前，不会实际生成元素。

使用示例

使用 Stream.generate() 方法来创建一个无限流，每个流元素都是通过 random.nextInt(100) 生成的随机数。

Random random = new Random();
// 使用 Stream.generate() 创建一个无限流来生成随机数
Stream<Integer> randomNumbers = Stream.generate(() -> random.nextInt(100)); // 生成 0 到 99 之间的随机数
// 打印生成的随机数
randomNumbers.forEach(System.out::println);

输出结果为：

7
95
47
98
....

使用 Stream.iterate() 创建无限流

Stream.iterate() 方法用于生成一个无限顺序流。这种流可以按照一定的规则从一个初始值开始，通过不断应用一个函数生成后续元素。

基本语法

无限流生成：

static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)

seed：流的初始元素。
f：一个应用于流中每个元素的单参数函数，用于生成下一个元素。

有限流生成（Java 9 引入）：

static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

seed：流的初始元素。
hasNext：一个 Predicate（断言函数），用于判断流是否应该继续生成下一个元素。
next：一个应用于流中每个元素的单参数函数，用于生成下一个元素。

使用示例

生成无限流：

// 使用 iterate() 方法生成一个无限流，从10开始，每次增加1
Stream<Integer> stream = Stream.iterate(10, n -> n + 1);
// 打印生成的数字
stream.forEach(System.out::println);

在满足条件时生成流：

// 使用 Java 9 的 iterate() 方法生成一个流，生成的流必须满足 n < 10
Stream<Integer> stream = Stream.iterate(0, n -> n < 10, n -> n + 1);
// 打印生成的数字
stream.forEach(System.out::println);

Stream.generate() 和 Stream.iterate() 的区别

Stream.iterate() ：明确指定起始元素和迭代规则，适合生成有规律的序列。
Stream.generate() ：适合生成无规律的、随机的或者基于外部状态的元素。

使用 IntStream，LongStream，DoubleStream 创建流

IntStream

// 从数组创建 IntStream
int[] intArray = {1, 2, 3, 4, 5};
IntStream intStreamFromArray = IntStream.of(intArray);

// 使用 range 创建 IntStream（不包含结束值）
IntStream intStreamRange = IntStream.range(1, 6);

// 使用 rangeClosed 创建 IntStream（包含结束值）
IntStream intStreamRangeClosed = IntStream.rangeClosed(1, 5);

// 使用 generate 创建无限流
IntStream intStreamGenerated = IntStream.generate(() -> 1).limit(5);

// 使用 iterate 创建无限流
IntStream intStreamIterated = IntStream.iterate(0, n -> n + 2).limit(5);

LongStream

// 从数组创建 LongStream
long[] longArray = {1L, 2L, 3L, 4L, 5L};
LongStream longStreamFromArray = LongStream.of(longArray);

// 使用 range 创建 LongStream（不包含结束值）
LongStream longStreamRange = LongStream.range(1L, 6L);

// 使用 rangeClosed 创建 LongStream（包含结束值）
LongStream longStreamRangeClosed = LongStream.rangeClosed(1L, 5L);

// 使用 generate 创建无限流
LongStream longStreamGenerated = LongStream.generate(() -> 1L).limit(5);

// 使用 iterate 创建无限流
LongStream longStreamIterated = LongStream.iterate(0L, n -> n + 2).limit(5);

DoubleStream

// 从数组创建 DoubleStream
double[] doubleArray = {1.0, 2.0, 3.0, 4.0, 5.0};
DoubleStream doubleStreamFromArray = DoubleStream.of(doubleArray);

// 使用 generate 创建无限流
DoubleStream doubleStreamGenerated = DoubleStream.generate(() -> Math.random()).limit(5);

// 使用 iterate 创建无限流
DoubleStream doubleStreamIterated = DoubleStream.iterate(0.0, n -> n + 0.5).limit(5);

使用 Stream.concat() 方法合并 Stream

Stream.concat() 用于将两个流连接成一个流。这两个流可以是任何类型的流，只要它们的元素类型相同。

基本语法

使用示例

Stream<String> stream1 = Stream.of("A", "D", "C");
Stream<String> stream2 = Stream.of("B", "E", "F");

// 将 stream1 和 stram2 连接成两个流。
Stream<String> resultStream = Stream.concat(stream1, stream2);

resultStream.forEach(System.out::println);

输出结果为：

A
D
C
B
E
F

使用 builder() 创建流

Stream.builder() 方法可以用来创建一个 Stream 的构建器（Builder），然后可以向其中添加元素，最后构建一个 Stream。

使用示例

//创建一个字符串流
Stream<String> stream = Stream.<String>builder()
    .add("apple")
    .add("banana")
    .add("cherry")
    .build();
//创建一个整数流
Stream<Integer> stream = Stream.<Integer>builder()
	.add(1)
	.add(2)
	.add(3)
	.add(4)
	.build();
//创建一个 Double 类型的流
Stream<Double> stream = Stream.<Double>builder()
	.add(1.1)
	.add(2.2)
	.add(3.3)
	.build();
//创建一个自定义对象流
Stream<Person> stream = Stream.<Person>builder()
	.add(new Person("Alice", 30))
	.add(new Person("Bob", 25))
	.add(new Person("Charlie", 35))
	.build();

使用 empty() 创建

Stream.empty() 方法用于创建一个空的流。

使用示例

Stream<String> emptyStream = Stream.empty();

Stream.empty() 常用来判断处理 Stream 为 null 时的默认值，例如：

public static Stream<String> getStreamFromData(List<String> data) {
   return data == null ? Stream.empty() : data.stream();
}

或者与 Optional 结合使用：

Optional<String> optionalValue = Optional.ofNullable(null);
// 将 Optional 的 String 转换成 Stream，如果 Optional 的 String 为 null，则返回 Stream.empty()
Stream<String> stream = optionalValue.map(Stream::of).orElseGet(Stream::empty);

中间操作

filter 方法

filter() 允许根据给定的条件（即 Predicate）过滤流中的元素。

使用示例

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 将 List 转换成成Stream，并通过 filter 过滤出来偶数，最终再将过滤出来的数据转换成List
List<Integer> evenNumbers = numbers.stream()
	   .filter(n -> n % 2 == 0)
    	.collect(Collectors.toList()); 
System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]

map 方法

map() 方法用于将一个函数应用于流中的每个元素，并将结果收集到一个新的流中。

使用示例

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 将 List 的每个元素都乘以2
List<Integer> doubled = numbers.stream()
	   .map(n -> n * 2)
	   .collect(Collectors.toList());
System.out.println(doubled);  // 输出 [2, 4, 6, 8, 10]

flatmap 方法

flatMap() 用来将一个流中的每个元素映射为一个新的流，然后将这些流合并成一个单一的流。

使用示例

List<List<String>> listOfLists = Arrays.asList(
		Arrays.asList("a", "b", "c"),
		Arrays.asList("d", "e", "f"),
		Arrays.asList("g", "h", "i")
);

List<String> flatList = listOfLists.stream()
		.flatMap(List::stream)
		.collect(Collectors.toList());

System.out.println(flatList); // [a, b, c, d, e, f, g, h, i]

mapMulti 方法

mapMulti() 是 Java 16 中引入的一个新的 Stream API 方法，它允许你在处理流中的每个元素时生成零个、一个或多个结果，类似于先使用 map() 然后再使用 flatMap() 的组合，但更为高效和直观。

基本语法

mapMulti() 使用一个 BiConsumer<T, Consumer<R>> 函数作为参数。对于流中的每个元素，BiConsumer 会被调用，其中：

T 是流中元素的类型。
Consumer<R> 是一个消费者，你可以通过调用它的 accept(R r) 方法来生成多个结果元素。

使用示例

List<String> words = List.of("apple", "banana", "cherry");

List<Character> characters = words.stream()
	.<Character>mapMulti((word, consumer) -> {
		for (char c : word.toCharArray()) {
			consumer.accept(c);
		}
	})
	.collect(Collectors.toList());

System.out.println(characters); // 输出 [a, p, p, l, e, b, a, n, a, n, a, c, h, e, r, r, y]

sorted 方法

Stream 接口的 sorted() 方法用于对流中的元素进行排序。它有两种主要用法：

自然排序（使用元素的 Comparable 接口）：
- 如果流中的元素实现了 Comparable 接口，那么可以直接使用 sorted() 方法对其进行自然排序。
自定义排序（使用 Comparator 接口）：
- 可以通过传递一个 Comparator 对象给 sorted() 方法来实现自定义排序。

使用示例

自然排序

List<String> names = Arrays.asList("John", "Alice", "Bob");

// 自然排序
List<String> sortedNames = names.stream()
		.sorted()
		.toList();

System.out.println(sortedNames); // 输出: [Alice, Bob, John]

自定义排序

List<String> names = Arrays.asList("John", "Alice", "Bob");

// 按字符串长度进行排序
List<String> sortedByLength = names.stream()
	   .sorted(Comparator.comparingInt(String::length))
	   .toList();

System.out.println(sortedByLength); // 输出: [Bob, John, Alice]

逆序排序

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);

// 逆序排序
List<Integer> sortedNumbers = numbers.stream()
		 .sorted(Comparator.reverseOrder())
		 .toList();

System.out.println(sortedNumbers); // 输出: [9, 5, 4, 3, 1, 1]

按多个属性排序

List<Person> people = Arrays.asList(
	new Person("John", 25),
	new Person("Alice", 30),
	new Person("Bob", 25)
);

// 按年龄升序排序，如果年龄相同则按名字升序排序
List<Person> sortedPeople = people.stream()
	  .sorted(Comparator.comparingInt((Person p) -> p.age)
	  .thenComparing(p -> p.name))
	  .toList();

System.out.println(sortedPeople); // 输出: [Bob (25), John (25), Alice (30)]

distinct 方法

distinct() 方法用于返回一个去掉重复元素（根据 Object.equals(Object) 的自然等同性）后组成的流。

使用示例

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
        
numbers.stream()
	   .distinct()
	   .forEach(System.out::println);
// 输出: 1, 2, 3, 4, 5

limit 方法

limit() 方法用于获取流的前 n 个元素。

使用示例

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

names.stream()
	 .limit(3)
	 .forEach(System.out::println); 
// 输出：
// Alice
// Bob
// Charlie

skip 方法

skip() 方法用于跳过流中的前 N 个元素

使用示例

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

List<String> result = names.stream()
	   .skip(2)
	   .collect(Collectors.toList());

System.out.println(result); // 输出: [Charlie, David, Eve]

takeWhile 方法

takeWhile() 方法是在 Java 9 中引入的方法，用于从流中获取满足指定条件的元素，直到遇到不满足条件的元素为止。

使用示例

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 2, 1);

List<Integer> result = numbers.stream()
	  .takeWhile(n -> n < 4)
	  .collect(Collectors.toList());

System.out.println(result); // 输出: [1, 2, 3]，遇到4就终止，无论后面的元素是否满足小于4，都不输出。

dropWhile

dropWhile() 是 Java 9 引入的方法，它用于丢弃流中从开头开始满足给定条件的元素，直到遇到第一个不满足条件的元素为止。之后的元素将会被保留在流中。

使用示例

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// [1,2,3,4] 都满足 dropWhile() 的条件，所以都被丢弃。
List<Integer> result = numbers.stream()
        .dropWhile(n -> n < 5)
        .collect(Collectors.toList());

System.out.println(result); // 输出: [5, 6, 7, 8, 9, 10]

终端操作

collect 方法

collect() 是 Stream API 中一个常用的终端操作，用于将流中的元素累积到某种结果中。

使用示例

将流转换为列表

List<String> list = Stream.of("a", "b", "c")
	 .collect(Collectors.toList());

将流转换为集合

Set<String> set = Stream.of("a", "b", "c", "a")
   .collect(Collectors.toSet());

将流转换成 Map

List<User> users = Arrays.asList(new User(1, "Alice"), new User(2, "Bob"), new User(3, "Charlie"));
// 将 user 列表转换成Map，Map的 key 为 id，value 为 user
Map<Integer, User> userMap = users.stream()
	.collect(Collectors.toMap(User::getId, user -> user));

userMap.forEach((id, user) -> System.out.println(id + ": " + user.getName()));

// 将 user 列表转换成Map，Map的 key 为列表元素，value 为元素的长度
Map<String, Integer> map = Stream.of("a", "bb", "ccc")
	.collect(Collectors.toMap(t -> t, String::length));

//Map<String, Integer> map = Stream.of("a", "bb", "ccc")
//	.collect(Collectors.toMap(Function.identity(), String::length));
map.forEach((k, v) -> System.out.println("key: " + k + ", value: " + v));

将流转换为特定类型的集合

LinkedList<String> linkedList = Stream.of("a", "b", "c")
	.collect(Collectors.toCollection(LinkedList::new));	

ArrayList<String> arrayList = Stream.of("a", "b", "c")
	.collect(Collectors.toCollection(ArrayList::new));

连接流中的字符串

String result = Stream.of("a", "b", "c")
	 .collect(Collectors.joining(", "));

计算流中元素的总和

int sum = Stream.of(1, 2, 3, 4)
   .collect(Collectors.summingInt(Integer::intValue));

计算流中元素的平均值

// 统计 List 中元素的平均值
double average = Stream.of(1, 2, 3, 4)
  .collect(Collectors.averagingInt(Integer::intValue));

计算流中元素的统计信息

// 统计 List 中元素的总值
IntSummaryStatistics stats = Stream.of(1, 2, 3, 4)
	.collect(Collectors.summarizingInt(Integer::intValue));

分组

// 将 List 元素根据元素的长度进行分组
Map<Integer, List<String>> groupByLength = Stream.of("a", "bb", "ccc", "dd")
                .collect(Collectors.groupingBy(String::length));
                
groupByLength.forEach((k, v) -> System.out.println("key: " + k + ", value: " + v));

// 输出：
// key: 1, value: [a]
// key: 2, value: [bb, dd]
// key: 3, value: [ccc]

分区

// 将满足条件的值存入 key = true 中，不满足的存如 key = false 中。
Map<Boolean, List<Integer>> partitioned = Stream.of(1, 2, 3, 4, 5, 6)  
        .collect(Collectors.partitioningBy(n -> n % 2 == 0));
partitioned.forEach((k, v) -> System.out.println("key: " + k + ", value: " + v));
// 输出：
// key: false, value: [1, 3, 5]
// key: true, value: [2, 4, 6]

将流元素组合为一个单一的值

// 将 List 的元素组合成一个字符串
String concatenated = Stream.of("a", "b", "c")
	.collect(Collectors.reducing("", String::concat));
System.out.println(concatenated); //abc

自定义累加器

// 将 Stream 内的元素加入到 ArrayList 中。
List<String> result = Stream.of("a", "b", "c")
	.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

使用的 collection 方法为：

<R> R collect(Supplier<R> supplier,
	  BiConsumer<R, ? super T> accumulator,
	  BiConsumer<R, R> combiner);

方法的执行逻辑：

R result = supplier.get(); //调用 new ArrayList()
for (T element : this stream)     // 遍历 Stream 内元素
	accumulator. accept(result, element); // 调用 ArrayList.add() 方法将元素加入到 ArrayList
return result;

forEach 方法

forEach() 是 Stream 接口中的一个终端操作，用于遍历流中的每一个元素。

使用示例

List<String> list = Arrays.asList("A", "B", "C", "D");
list.stream().forEach(element -> System.out.println(element));
// or
list.stream().forEach(System.out::println);

toArray 方法

toArray() 方法可以将流中的元素收集到一个数组中。

使用示例


Stream<String> stream = Stream.of("a", "b", "c", "d");
// 将流转换为对象数组
Object[] array = stream.toArray();

// 将流转换为特定类型的数组
String[] array = stream.toArray(String[]::new);

toList 方法

toList() 是 Java 16 中引入的一种简单方法，可以将流元素收集到一个 List 中。

使用示例

// 生成简单的整数列表
List<Integer> list = Stream.of(1, 2, 3, 4, 5)
   .toList();

reduce 方法

reduce() 方法通过指定的累加器函数，将流中的元素组合成一个单一的结果。

使用示例

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 计算和
int sum = numbers.stream()
	 .reduce(0, (a, b) -> a + b);

// 计算乘积
int product = numbers.stream()
	 .reduce(1, (a, b) -> a * b);

// 寻找最大值
Optional<Integer> max = numbers.stream()
   .reduce(Integer::max);

// 寻找最小值
Optional<Integer> min = numbers.stream()
   .reduce(Integer::min);


// 字符串连接
List<String> strings = Arrays.asList("A", "B", "C", "D");
String result = strings.stream()
	.reduce("", (a, b) -> a + b);

min 方法

min() 用于在流中查找最小的元素。这个方法需要一个比较器来确定元素的顺序。

使用示例

List<Integer> numbers = Arrays.asList(3, 5, 1, 10, 2, 7);
Optional<Integer> minNumber = numbers.stream().min(Integer::compareTo);
System.out.println(minNumber.get()); // 1

max 方法

max() 用于在流中查找最大的元素。这个方法需要一个比较器来确定元素的顺序。

使用示例

List<Integer> numbers = Arrays.asList(3, 5, 1, 10, 2, 7);
Optional<Integer> maxNumber = numbers.stream().max(Integer::compareTo);
System.out.println(maxNumber.get()); // 10

count 方法

count() 方法可以用来计算流中的元素数量

使用示例

List<String> list = Arrays.asList("apple", "banana", "orange");
long count = list.stream().count();
System.out.println("元素数量: " + count); // 输出: 元素数量: 3

anyMatch, allMatch, noneMatch 方法

anyMatch、allMatch 和 noneMatch 三个方法，用于对流中的元素进行匹配测试。

anyMatch 方法用于检查流中的任何一个元素是否匹配给定的条件。如果有任何一个元素匹配，返回 true，否则返回 false。
allMatch 方法用于检查流中的所有元素是否都匹配给定的条件。如果所有元素都匹配，返回 true，否则返回 false。
noneMatch 方法用于检查流中的所有元素是否都不匹配给定的条件。如果所有元素都不匹配，返回 true，否则返回 false。

使用示例

List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
// 判断所有的元素是否都是偶数。
boolean allEven = numbers.stream()
		.allMatch(number -> number % 2 == 0);
System.out.println(allEven);

// 判断是否所有的元素都大于10
boolean none = numbers.stream().noneMatch(number -> number > 10);
System.out.println(none);

// 判断是否有元素大于7
boolean any = numbers.stream().anyMatch(number -> number > 7);
System.out.println(any);

findFirst, findAny 方法

findFirst() 和 findAny() 方法，用于查找流中的元素。

findFirst() 方法用于获取流中的第一个元素。
findAny() 方法用于获取流中的某个元素，可能是第一个，也可能是其他的元素。在顺序流中会获取到第一个元素，在并行流中可能会获取到其他元素。

使用示例

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
Optional<String> firstElement = list.stream().findFirst();

Optional<String> firstElement = list.parallelStream().findAny();

posted @ 2024-10-31 23:58 Jacob-Chen 阅读(587) 评论(0) 收藏举报

刷新页面返回顶部

Jacob-Chen

Java Stream API 总结

Java Stream API 介绍

Stream 分类

顺序流（Sequential Stream）

并行流（Parallel Stream）

无限流 （Infinite Stream）

常用的 Stream 操作

创建 Stream

从集合创建流

从集合创建顺序 Stream

从集合创建并行 Stream

从数组创建 Stream

使用 Arrays.stream() 创建 Stream

使用 Stream.of() 创建 Stream

使用 Stream.ofNullable() 创建 Stream

创建无限流

使用 Stream.generate() 创建无限流

基本语法

特点

使用示例

使用 Stream.iterate() 创建无限流

基本语法

使用示例

Stream.generate() 和 Stream.iterate() 的区别

使用 IntStream，LongStream，DoubleStream 创建流

IntStream

LongStream

DoubleStream

使用 Stream.concat() 方法合并 Stream

基本语法

使用示例

使用 builder() 创建流

使用示例

使用 empty() 创建

使用示例

中间操作

filter 方法

使用示例

map 方法

使用示例

flatmap 方法

使用示例

mapMulti 方法

基本语法

使用示例

sorted 方法

使用示例

distinct 方法

使用示例

limit 方法

使用示例

skip 方法

使用示例

takeWhile 方法

使用示例

dropWhile

使用示例

终端操作

collect 方法

使用示例

将流转换为列表

将流转换为集合

将流转换成 Map

将流转换为特定类型的集合

连接流中的字符串

计算流中元素的总和

计算流中元素的平均值

计算流中元素的统计信息

分组

分区

将流元素组合为一个单一的值

自定义累加器

forEach 方法

使用示例

toArray 方法

使用示例

toList 方法

使用示例

reduce 方法

无限流（Infinite Stream）