Java 8中使用Stream来操作集合

Java 8中使用Stream来操作集合

在Java 8中，你可以使用Stream API来操作集合，这使得集合的处理变得更加简洁和函数式。Stream API提供了一系列的中间操作（intermediate operations）和终端操作（terminal operations），可以很容易地对集合进行过滤、映射、排序、聚合等操作。

下面是一些使用Stream API操作集合的例子：

1. 过滤元素

使用filter方法过滤集合中的元素：

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

List<Integer> evenNumbers = numbers.stream()
    .filter(num -> num % 2 == 0)
    .collect(Collectors.toList());

System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]

2. 映射元素

使用map方法将集合中的元素映射成新的形式：

List<String> strings = Arrays.asList("a", "b", "c");

List<String> upperCaseStrings = strings.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

System.out.println(upperCaseStrings); // 输出: [A, B, C]

3. 排序元素

使用sorted方法对集合中的元素进行排序：

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

List<String> sortedWords = words.stream()
    .sorted()
    .collect(Collectors.toList());

System.out.println(sortedWords); // 输出: [apple, banana, cherry]

4. 聚合元素

使用reduce方法对集合中的元素进行聚合操作，例如求和：

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

int sum = numbers.stream()
    .reduce(0, Integer::sum);

System.out.println(sum); // 输出: 15

5. 查找元素

使用anyMatch, allMatch, noneMatch来查找匹配特定条件的元素：

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

boolean allPositive = numbers.stream()
    .allMatch(num -> num > 0);

System.out.println(allPositive); // 输出: true

6. 收集到不同的集合类型

除了收集到List，你还可以收集到Set，Map等其他集合类型：

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3);

Set<Integer> uniqueNumbers = numbers.stream()
    .distinct()
    .collect(Collectors.toSet());

System.out.println(uniqueNumbers); // 输出: [1, 2, 3]

7. 分组

使用groupingBy对集合中的元素进行分组：

List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date");

Map<Integer, List<String>> groupedByLength = fruits.stream()
    .collect(Collectors.groupingBy(fruit -> fruit.length()));

System.out.println(groupedByLength);
// 输出:
// {
//    5=[apple],
//    6=[banana, cherry],
//    4=[date]
// }

8. 扁平化集合

使用flatMap来将集合中的元素转换成流，并将这些流扁平化成一个流：

List<List<Integer>> lists = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);

List<Integer> flattenedList = lists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());

System.out.println(flattenedList); // 输出: [1, 2, 3, 4, 5, 6]

使用Stream API可以大大简化对集合的操作，并且代码更加清晰和易于理解。不过，请注意，Stream API的操作通常是惰性的（lazy），

stream高阶用法

Java 8中的Stream API提供了许多高阶用法，这些用法允许你以更函数式的方式处理数据。下面是一些Java 8中Stream API的高阶用法示例：

1. 匹配特定条件

使用anyMatch、allMatch和noneMatch来检查Stream中的元素是否满足特定的条件。

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

// 检查是否有任何元素以'a'开头
boolean anyStartWithA = list.stream().anyMatch(s -> s.startsWith("a"));
System.out.println(anyStartWithA); // 输出: true

// 检查所有元素是否都以'a'开头
boolean allStartWithA = list.stream().allMatch(s -> s.startsWith("a"));
System.out.println(allStartWithA); // 输出: false

// 检查是否没有元素以'z'开头
boolean noneStartWithZ = list.stream().noneMatch(s -> s.startsWith("z"));
System.out.println(noneStartWithZ); // 输出: true

2. 收集器（Collectors）

使用Collectors类来执行更复杂的聚合操作，如分组、计数、求和等。

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

// 分组
Map<String, Long> wordCount = words.stream()
    .collect(Collectors.groupingBy(word -> word, Collectors.counting()));
System.out.println(wordCount); // 输出: {apple=2, banana=1, cherry=1}

// 计数
long count = words.stream().collect(Collectors.counting());
System.out.println(count); // 输出: 4

// 求和
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
int sum = numbers.stream().collect(Collectors.summingInt(number -> number));
System.out.println(sum); // 输出: 10

// 平均值
double average = numbers.stream().collect(Collectors.averagingInt(number -> number));
System.out.println(average); // 输出: 2.5

3. 排序

使用sorted方法对Stream中的元素进行排序。

List<String> words = Arrays.asList("banana", "apple", "cherry");
List<String> sortedWords = words.stream()
    .sorted()
    .collect(Collectors.toList());
System.out.println(sortedWords); // 输出: [apple, banana, cherry]

4. 查找元素

使用findFirst和findAny来查找Stream中的元素。

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

// 查找第一个元素
Optional<Integer> firstNumber = numbers.stream().findFirst();
System.out.println(firstNumber.get()); // 输出: 1

// 查找任意元素（并行流中更高效）
Optional<Integer> anyNumber = numbers.parallelStream().findAny();
System.out.println(anyNumber.get()); // 输出: 任意一个数字，可能是1, 2, 3, 4, 5中的任何一个

5. 流的并行处理

使用parallelStream来并行处理数据，这在大数据集上可以提高性能。

List<Integer> numbers = IntStream.range(0, 1000000).boxed().collect(Collectors.toList());

// 并行流求和
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();
System.out.println("Sum: " + sum); // 输出: 499999500000

6. 流操作的组合

你可以组合多个流操作来创建更复杂的数据处理管道。

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

// 过滤出长度大于4的单词，转换为大写，并排序
List<String> result = words.stream()
    .filter(word -> word.length() > 4)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(result); // 输出: [BANANA]