Java Stream必知必会

下文笔者讲述Java中Stream的使用方法大全，如下所示

Java之Stream简介说明

在JDK1.8之后
  Stream为我们的程序提供快捷操作集合的方法
   如:Stream集合提供
       过滤、映射、排序、聚合等
	   使我们编写代码方法，下文笔者将讲述一些具体的使用方法,如下所示

例

创建 Stream

list<String> list = Arrays.asList("java265.com", "java编程网站", "最爱的java语言");
Stream<String> stream1 = list.stream();

借助数组创建 Stream
  可使用 Arrays.stream()方法创建stream
  
String[] array = {"java265.com", "java编程网站", "最爱的java语言"};
Stream<String> stream2 = Arrays.stream(array);

Stream中间操作

filter:
  用于过滤元素
     可以指定过滤条件
	 
例：过滤 b开头的字符串 
 
list.stream()
   .filter(s -> s.startsWith("b"))
   .forEach(System.out::println); // 输出: apple


map
   转换元素
   map方法的功能:
     将流中的每个元素按照指定的函数进行转换
	 如:
	   将字符串转换为大写：
 
list.stream()
   .map(String::toUpperCase)
   .forEach(System.out::println); // 输出: APPLE BANANA CHERRY

终止操作

 forEach:
    遍历元素
 forEach方法
    用于遍历流中的每个元素并执行指定的操作
	
例
  list.stream().forEach(System.out::println);
   collect
     收集结果到集合
   collect方法的功能
     将流中的元素收集到指定的集合中

例:
  获取长度大于 8字符串到一个新的列表中：

List<String> result1 = list.stream()
   .filter(s -> s.length() > 8)
   .collect(Collectors.toList());

// 或者使用 toList() 方法（Java 16 及以上版本）
List<String> result2 = list.stream()
   .filter(s -> s.length() > 5)
   .toList();

---

Stream中级用法

1.排序

 sorted
   自然排序或自定义排序
 
 sorted方法可以对流中的元素进行排序
  当元素实现Comparable接口
   可直接使用无参sorted 方法进行自然排序
 
 例:
list.stream()
   .sorted()
   .forEach(System.out::println);  

如需要自定义排序规则
  可传入一个Comparator比较器
  例:
    按照字符串长度倒序排序
	
list.stream()
   .sorted(Comparator.reverseOrder())
   .forEach(System.out::println);

2.去重

使用distinct方法可以去除流中的重复元素
 例:
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
   .distinct()
   .toList();

3.聚合操作

    reduce
	   归约操作
	reduce方法可以对流中的元素进行归约操作

例
  求和、求乘积等

Optional<Integer> sum = numbers.stream()
   .reduce((a, b) -> a + b); // 可替换为.reduce(Integer::sum);
System.out.println(sum.get()); // 输出: 19

---

三、高级用法

1.并行流

    parallelStream
	  并行处理(提高效率)
	   使用parallelStream方法可创建一个并行流
	   它会在多个线程上并行处理流中的元素,提高处理效率
	例:
	  计算满足条件的元素数量
long count = list.parallelStream()
   .filter(s -> s.length() > 5)
   .count();

2.短路操作

    anyMatch、allMatch、noneMatch：短路匹配：这些方法用于在流中进行短路匹配操作。
        anyMatch：只要流中有一个元素满足条件就返回 true
	例：
 
boolean anyStartsWithA = list.stream()
   .anyMatch(s -> s.startsWith("j"));
System.out.println(anyStartsWithA); // 输出: true
 
 allMatch:
   只有流中所有元素都满足条件才返回 true
   例如：
 
boolean allStartsWithA = list.stream()
   .allMatch(s -> s.startsWith("a"));
System.out.println(allStartsWithA); // 输出: false

noneMatch:
  如果流中没有元素满足条件则返回true
  例:
boolean noneStartsWithZ = list.stream()
   .noneMatch(s -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // 输出: true

3.分组和分区

 Collectors.groupingBy:
    分组
 使用groupingBy方法可以根据指定的分类函数将流中的元素分组到一个Map中
  例:
    根据字符串的首字母进行分组
Map<Character, List<String>> groupedByFirstLetter = list.stream()
   .collect(Collectors.groupingBy(s -> s.charAt(0)));
System.out.println(groupedByFirstLetter); // {a=[apple], b=[banana], c=[cherry]}

 Collectors.partitioningBy:
    分区
  partitioningBy方法根据指定的布尔条件将流中的元素分区到一个Map中
    键为true和false
	例:
	  根据字符串长度是否大于 5 进行分区：
 
Map<Boolean, List<String>> partitioned = list.stream()
   .collect(Collectors.partitioningBy(s -> s.length() > 5));  
System.out.println(partitioned);

4.收集到Map

 Collectors.toMap
   收集到Map
     使用toMap方法可以将流中的元素收集到一个Map中
	  需要指定键和值的映射函数
	   例
Map<String, Integer> map = list.stream()
   .collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map);

---

flatMap用法

flatMap方法
 用于将流中每个元素转换为另一个流
 然后将这些流扁平化成一个单一流
  这在处理嵌套集合时非常有用
  例
List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("apple", "banana"),
    Arrays.asList("cherry", "date"),
    Arrays.asList("fig", "grape")
);

// 使用 flatMap 将嵌套列表扁平化
List<String> flattenedList = listOfLists.stream()
   .flatMap(List::stream)
   .collect(Collectors.toList());

System.out.println(flattenedList);  

peek用法

peek方法
  用于调试
  它允许在流的每个元素上执行某个操作(如打印)
   而不会改变流中的元素
    peek 返回一个新的流
	其中包含与原始流相同的元素
	例
List<String> list = Arrays.asList("java265.com", "java编程网站", "最爱的java语言");

List<String> result = list.stream()
   .peek(s -> System.out.println("Processing: " + s)) // 打印每个元素
   .map(String::toUpperCase)
   .collect(Collectors.toList());

System.out.println(result);  

limit用法

limit方法
  用于限制流中的元素数量
   例

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

List<String> limitedList = list.stream()
   .limit(3)
   .collect(Collectors.toList());

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

skip用法

skip方法
  用于跳过流中前n个元素
  
  例
List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");

List<String> skippedList = list.stream()
   .skip(3)
   .collect(Collectors.toList());

System.out.println(skippedList); // 输出: [date, fig, grape]

min和max

min和max方法
  用于查找流中的最小值和最大值
  例：
List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);

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

System.out.println(min.get()); // 输出: 10

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

System.out.println(max.get()); // 输出: 50

findAny和findFirst

findAny和findFirst方法
  用于查找流中任意元素和第一个元素

List<String> list = Arrays.asList("java265.com", "java编程网站", "最爱的java语言");

// 查找任意一个元素
Optional<String> anyElement = list.stream().findAny();

System.out.println(anyElement.get());  

// 查找第一个元素
Optional<String> firstElement = list.stream().findFirst();

System.out.println(firstElement.get());