Java 8 Stream 流的常用方法总结

超、凢脫俗 2024-02-05 12:49 36阅读 0赞

## 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());
            //实体类排序 两个字段排序参考 https://www.cnblogs.com/codecat/p/10873757.html
            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 解决实际问题。