Java 8 Stream 流的常用方法总结

Java 8 Stream 流的常用方法总结

Java 8 引入了一个新的 API：Stream API，它允许我们以声明式的方式处理数据集合。Stream API 提供了一系列强大的方法，可以帮助我们更简洁、高效地处理数据。本文将总结 Java 8 Stream 流的常用方法，并提供相应的代码示例。

1. 创建 Stream

首先，我们需要了解如何创建一个 Stream。以下是几种创建 Stream 的方法：

1.1 从集合创建

List<String> list = Arrays.asList("A", "B", "C");
Stream<String> stream = list.stream();

1.2 从数组创建

String[] array = {"A", "B", "C"};
Stream<String> stream = Arrays.stream(array);

1.3 生成 Stream

Stream<Integer> stream = Stream.generate(() -> new Random().nextInt());
stream.limit(5).forEach(System.out::println);

2. 中间操作

中间操作是在 Stream 上执行的操作，它们不会生成最终结果，而是产生一个新的 Stream。这些操作通常具有无状态性，即多次调用同一个中间操作可能会产生不同的结果。

2.1 filter

filter(Predicate<T> predicate) 方法根据给定的谓词过滤元素。例如，筛选出列表中的偶数：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
                                 .filter(n -> n % 2 == 0)
                                 .collect(Collectors.toList());

2.2 map

map(Function<T, R> mapper) 方法将 Stream 中的每个元素映射到另一个元素。例如，将列表中的每个字符串转换为大写：

List<String> words = Arrays.asList("hello", "world");
List<String> upperCaseWords = words.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList());

2.3 peek

peek(Consumer<T> action) 方法在 Stream 中的每个元素上执行一个操作，但不会改变元素本身。例如，打印列表中的每个元素：

List<String> words = Arrays.asList("hello", "world");
words.stream()
     .peek(System.out::println)
     .collect(Collectors.toList());

2.4 distinct

distinct() 方法返回一个剔除重复元素的 Stream。例如，移除列表中的重复字符串：

List<String> words = Arrays.asList("hello", "world", "hello");
List<String> uniqueWords = words.stream()
                                 .distinct()
                                 .collect(Collectors.toList());

2.5 sorted

sorted() 方法对 Stream 中的元素进行排序。例如，对数字列表进行升序排序：

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sortedNumbers = numbers.stream()
                                  .sorted()
                                  .collect(Collectors.toList());

2.6 limit

limit(long maxSize) 方法返回一个 Stream，其中包含最多 maxSize 个元素。例如，获取列表中的前三个元素：

List<String> words = Arrays.asList("A", "B", "C", "D", "E");
List<String> firstThreeWords = words.stream()
                                  .limit(3)
                                  .collect(Collectors.toList());

2.7 skip

skip(long n) 方法返回一个 Stream，跳过前 n 个元素。例如，跳过列表中的前两个元素：

List<String> words = Arrays.asList("A", "B", "C", "D", "E");
List<String> skipFirstTwoWords = words.stream()
                                     .skip(2)
                                     .collect(Collectors.toList());

可以配合limit实现分页

/**
         * //limit(n)：获取n个元素
         * //skip(n)：跳过n元素，配合limit(n)可实现分页
         */
        int currentPage = 1;//页数（必须大于等于1）
        int pageSize = 3;//每页数量
        List<String> pageData = stringList.stream().skip((currentPage - 1) * pageSize).limit(pageSize).
                collect(Collectors.toList());
        int count = stringList.size();//总数
        int pagecount = 0;//总页数
        int i = count % pageSize;
        if (i>0){
            pagecount = count / pageSize + 1;
        }else {
            pagecount = count / pageSize;
        }
        System.out.println("skip/limit配合分页数据:"+pageData);
        System.out.println("总数:"+count);
        System.out.println("总页数:"+pagecount);

2.8 groupingBy

groupingBy(Function<T, K> classifier) 方法根据给定的分类器对元素进行分组。例如，按字符串长度分组：

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
Map<Integer, List<String>> groupedWords = words.stream()
                                             .collect(Collectors.groupingBy(word -> word.length()));

一些复杂数据的排序和分组

List<Map<String,Object>> listMapData = new ArrayList<>();
        Map<String,Object> map = new HashMap<>();
        Map<String,Object> map2 = new HashMap<>();
        Map<String,Object> map3 = new HashMap<>();
        map.put("age",18);
        map.put("name","张三");
        map2.put("age",20);
        map2.put("name","李四");
        map3.put("age",18);
        map3.put("name","王五");
        listMapData.add(map);
        listMapData.add(map2);
        listMapData.add(map3);
        System.out.println("排序前："+listMapData);
        //年龄排序 （会影响原数据）
        listMapData.sort((x,y)-> Integer.compare(Integer.valueOf(String.valueOf(x.get("age"))), Integer.valueOf(String.valueOf(y.get("age")))));
        //年龄排序 （数字排序）
        List<Map<String, Object>> aa = listMapData.stream().sorted((o1, o2) -> Integer.valueOf(String.valueOf(o1.get("age"))) - Integer.valueOf(String.valueOf(o2.get("age")))).collect(Collectors.toList());
        //姓名排序（字符串排序）
        List<Map<String, Object>> abc = listMapData.stream().sorted((o1, o2) -> Collator.getInstance(Locale.TRADITIONAL_CHINESE).compare(o1.get("name"), o2.get("name"))).collect(Collectors.toList());
        //实体类排序 两个字段排序参考
        System.out.println("年龄排序后："+listMapData);
        System.out.println("年龄排序后："+aa);
        System.out.println("姓名排序后："+abc);

        /**
         * groupingBy分组
         */
        Map<Object, List<Map<String, Object>>> groupData = listMapData.stream().collect(Collectors.groupingBy(o -> o.get("age")));
        Map<Object, List<Map<String, Object>>> grouptwoData = listMapData.stream().collect(Collectors.groupingBy(o -> o.get("age")+"_"+o.get("name")));
        System.out.println("根据年龄分组后的数据："+groupData);
        System.out.println("根据年龄+姓名分组后的数据："+grouptwoData);

3. 终止操作

终止操作会产生一个结果，或者副作用。以下是一些常用的终止操作：

3.1 forEach

forEach(Consumer<T> action) 方法对 Stream 中的每个元素执行一个操作。例如，打印列表中的每个元素：

List<String> words = Arrays.asList("A", "B", "C");
words.stream().forEach(System.out::println);

3.2 count

count() 方法返回 Stream 中元素的数量。例如，获取列表中的元素个数：

List<String> words = Arrays.asList("A", "B", "C");
long wordCount = words.stream().count();

3.3 collect

collect(Collector<T, A, R> collector) 方法将 Stream 中的元素收集到一个集合中。例如，将列表中的元素收集到一个新的列表中：

List<String> words = Arrays.asList("A", "B", "C");
List<String> collectedWords = words.stream()
                                   .collect(Collectors.toList());

3.4 reduce

reduce(T identity, BinaryOperator<T> accumulator) 方法将 Stream 中的元素通过累加器进行累积，返回累积结果。例如，计算列表中所有数字的和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, Integer::sum);

3.5 min & max

min(Comparator<T> comparator) 和 max(Comparator<T> comparator) 方法分别返回 Stream 中的最小值和最大值。例如，找到列表中的最小和最大字符串：

List<String> words = Arrays.asList("apple", "banana", "cherry");
Optional<String> minWord = words.stream().min(Comparator.comparing(String::length));
Optional<String> maxWord = words.stream().max(Comparator.comparing(String::length));

3.6 anyMatch & allMatch

anyMatch(Predicate<T> predicate) 和 allMatch(Predicate<T> predicate) 方法分别检查 Stream 中是否存在至少一个元素满足给定谓词，以及 Stream 中的所有元素是否都满足给定谓词。例如，检查列表中是否有字符串长度大于 5，以及所有字符串长度是否都大于 5：

List<String> words = Arrays.asList("apple", "banana", "cherry");
boolean anyLongWord = words.stream().anyMatch(word -> word.length() > 5);
boolean allLongWords = words.stream().allMatch(word -> word.length() > 5);

结论

Java 8 的 Stream API 提供了一种简洁、高效的方式来处理数据集合。通过掌握这些常用方法，我们可以更好地利用 Stream API 解决实际问题。