【Java】常用Stream API

最新推荐文章于 2024-06-11 18:18:27 发布

程序员小菜鸡QAQ

最新推荐文章于 2024-06-11 18:18:27 发布

阅读量603

点赞数

分类专栏： java 文章标签： java python 开发语言

本文链接：https://blog.csdn.net/Java_Wxlin/article/details/132211443

版权

java 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

常见 Stream 流表达式

总体结构图

在这里插入图片描述

一、两大类型

中间操作(Intermediate Operations)

中间操作是指在Stream上执行的操作, 它们返回一个新的Stream, 允许你链式地进行多个中间操作.

终端操作(Terminal Operations)

对Stream进行最终处理的操作, 当调用终端操作时, Stream会开始执行中间操作, 并生成最终的结果或副作用.终端操作是Stream的"触发器", 一旦调用终端操作, Stream就不能再被使用, 也不能再进行中间操作.

二、中间操作

2.1 filter

用于根据指定条件过滤元素.它接收一个条件作为参数, 只保留满足条件的元素, 并生成一个新的Stream.

在这里插入图片描述

示例

    /** TODO **************************************  filter **************************************  */
    
    public static void filter() {
        List<String> tempList = Arrays.asList("小芳", "小李", "小林", "小王");
        List<String> resList = tempList.stream()
                .filter(s -> s.contains("王"))
                .collect(Collectors.toList());
        System.out.println(resList.toString());
    }

输出结果

[小王]

2.2 map

用于对每个元素执行映射操作, 将元素转换成另一种类型.它接收一个Function（映射函数）作为参数, 对每个元素应用该映射函数, 并生成一个新的Stream.

在这里插入图片描述

示例

 /** TODO **************************************  map **************************************  */
    
    public static void map() {
        List<String> tempList = Arrays.asList("小芳", "小李", "小林", "小王");
        List<String> resList = tempList.stream()
        .map(s -> "姓名: " + s)
        .collect(Collectors.toList());
        System.out.println(resList.toString());
    }

输出结果

  [姓名: 小芳, 姓名: 小李, 姓名: 小林, 姓名: 小王]

2.3 flatMap

类似于map操作，但是 flatMap 操作可以将每个元素映射成一个 Stream，然后把所有生成的 Stream 合并成一个新的Stream。

在这里插入图片描述

示例

新建一个静态内部类, 然后聚合类中的集合数据

@Data
static class Personnel {
    // 人员姓名
    private String name;
    // 人员标签
    private List<String> tagList;

    public Personnel(String name, List<String> tagList) {
        this.name = name;
        this.tagList = tagList;
    }
}

Tips: 就现在想要把 List 中的 tagList 聚合后进行处理, 代码如下:

public static void main(String[] args) {
    Personnel personA = new Personnel("张三", Arrays.asList("抽烟", "喝酒", "烫头"));
    Personnel personB = new Personnel("李斯", Arrays.asList("编码", "喝酒", "踢足球"));
    List<Personnel> personnelList = Arrays.asList(personA, personB);
    personnelList.stream()
            .flatMap(p -> p.getTagList().stream())
            .forEach(s -> System.out.print(s + " "));
}

输出结果

抽烟 喝酒 烫头 编码 喝酒 踢足球

2.4 sorted

用于对Stream中的元素进行排序，默认按照自然顺序进行排序。也可以传入自定义的Comparator来指定排序规则。

  /** TODO **************************************  sorted **************************************  */

    public static void sorted() {
        List<Integer> numList = Arrays.asList(10, 20, 18, 300, 30, 2);
        // ① 默认排序
        List<Integer> orderList = numList.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.printf("① 默认排序: %s%n", orderList);
        // ② 自定义排序
        List<Integer> orderDescList = numList.stream()
                .sorted((x, y) -> {
                    return y.compareTo(x);
                })
                .collect(Collectors.toList());
        System.out.printf("② 自定义排序: %s%n", orderDescList);
    }

输出结果

① 默认排序: [2, 10, 18, 20, 30, 300]
② 自定义排序: [300, 30, 20, 18, 10, 2]

2.5 distinct

用于去除 Stream 中重复的元素，确保最终的 Stream 中每个元素都是唯一的。

示例

   /** TODO **************************************  distinct **************************************  */

    public static void distinct() {
        List<Integer> numList = Arrays.asList(1,1,1,1,2,3,2,2);
        List<Integer> distinctList = numList.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(distinctList);
    }

输出结果

[1, 2, 3]

2.6 limit

用于限制Stream的大小，返回一个最大包含前n个元素的新Stream。

示例

 /** TODO **************************************  limit **************************************  */
    
    public static void limit(){
        List<Integer> numList = Arrays.asList(1,2,3,4,5,6,7,8);
        List<Integer> limitList = numList.stream()
                .limit(4)
                .collect(Collectors.toList());
        System.out.println(limitList);
    }

输出结果

[1, 2, 3, 4]

2.7 skip

用于跳过Stream中的前n个元素，返回一个丢弃了前n个元素后剩余元素的新Stream。

示例

    /** TODO **************************************  skip **************************************  */

    public static void skip(){
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        List<Integer> skipList = numList.stream()
                .skip(numList.size() - 2)
                .collect(Collectors.toList());
        System.out.println(skipList);
    }

输出结果

[7, 8]

2.8 peek

用于对每个元素执行一个操作，同时保持Stream的流。它可以用于调试或记录Stream中的元素。

示例

  /** TODO **************************************  peek **************************************  */

    public static void peek(){
        List<Integer> numList = Arrays.asList(5, 6, 7, 8);
        List<Integer> resList = numList.stream()
                .peek(System.out::println)
                .filter(s -> s == 5)
                .peek(s -> System.out.printf("过滤后的:%d%n", s))
                .collect(Collectors.toList());
    }

输出结果

5
过滤后的:5
6
7
8

三、终端操作

在Java Stream API中，终端操作（Terminal Operations）是对Stream进行最终处理的操作。
当调用终端操作时，Stream会开始执行中间操作，并生成最终的结果或副作用。
终端操作是Stream的触发器，一旦调用终端操作，Stream就不能再被使用，也不能再进行中间操作。

3.1 forEach

对Stream中的每个元素执行指定的操作，接收一个Consumer（消费者函数）作为参数。它通常用于对Stream中的元素进行输出或执行某些操作，但不会返回任何结果。

示例

  /** TODO **************************************  forEach **************************************  */

    public static void forEach(){
        // 给公司工资普涨 500
        List<Integer> salaryList = Arrays.asList(12000, 20000, 30000, 4000);
        salaryList.stream()
                .peek(s -> System.out.print("工资普涨前:" + s))
                .map(s -> s + 500)
                .forEach(s -> {
                    System.out.println("--工资普涨后:" + s);
                });
    }

输出结果

工资普涨前:12000--工资普涨后:12500
工资普涨前:20000--工资普涨后:20500
工资普涨前:30000--工资普涨后:30500
工资普涨前:4000--工资普涨后:4500

3.2 collect

用于将Stream中的元素收集到一个容器中，接收一个Collector（收集器）作为参数。
它允许你在Stream中执行各种集合操作，例如将元素收集到List、Set、Map等容器中。

示例

把 User 实体集合转换为 Map 集合,名字作为 key,工资作为 Name

 /** TODO **************************************  collect **************************************  */

public static void collectTest(){

        List<User> userList = Arrays.asList(new User("张三", 2000.5),
        new User("李斯", 11000.5),
        new User("王二", 12000.5),
        new User("张六", 32000.5),
        new User("赵公子", 1000000.0));
        Map<String, Double> userSalaryMap = userList.stream()
        .collect(Collectors.toMap(User::getName, User::getSalary));
        userSalaryMap.forEach((k, v) -> {
        System.out.printf("姓名:%s,工资:%.2f%n", k, v);
        });
  }

@Data
@AllArgsConstructor
static class User {
    private String name;
    private Double salary;
}

输出结果

姓名:张三,工资:2000.50
姓名:赵公子,工资:1000000.00
姓名:张六,工资:32000.50
姓名:李斯,工资:11000.50
姓名:王二,工资:12000.50

3.3 toArray

将Stream中的元素转换成一个数组。返回一个包含所有元素的数组，返回的数组类型是根据流元素的类型自动推断的。如果流是空的，将返回一个长度为0的数组。

示例

  /** TODO **************************************  toArray **************************************  */

    public static void toArray(){
        // 示例整数流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
        // 使用toArray()将流中的元素收集到一个数组中
        int[] intArray = intStream.toArray();
        // 输出结果数组
        System.out.println(Arrays.toString(intArray));
        
    }

输出结果

[1, 2, 3, 4, 5]

3.4 reduce

Stream 类的 reduce() 方法是用于将流中的元素进行归约操作的方法。
接收一个 BinaryOperator（二元运算函数作为参数，用于对两个元素进行操作，并返回一个合并后的结果。
它可以将流中的所有元素按照指定的规则进行合并，并返回一个 Optional 对象，因为流可能为空。

示例

  /** TODO **************************************  reduce **************************************  */

    public static void reduceTest(){
        // 示例整数流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
        // 使用reduce()将流中的整数相加得到总和
        OptionalInt sumOptional = intStream.reduce((a, b) -> a + b);

        // 获取结果总和，如果流为空，则给出一个默认值0
        int sum = sumOptional.orElse(0);
        // 输出结果总和
        System.out.println("总和: " + sum);
    }

输出结果

总和: 15

3.5 min / max

Stream 类的 min() 和 max() 方法是用于查找流中的最小值和最大值的终端操作。它们接受一个 Comparator 对象作为参数来确定元素的顺序，并返回一个 Optional 对象，因为流可能为空。

示例

假设我们有一个包含整数的流，并且我们想找到其中的最小值和最大值

    /** TODO **************************************  min / max **************************************  */

    public static void minAndMaxTest(){
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用min()找到最小值
        Optional<Integer> minOptional = integerStream.min(Integer::compareTo);
        if (minOptional.isPresent()) {
            System.out.println("最小值为: " + minOptional.get());
        } else {
            System.out.println("流为空.");
        }

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用max()找到最大值
        Optional<Integer> maxOptional = newIntegerStream.max(Integer::compareTo);
        if (maxOptional.isPresent()) {
            System.out.println("最大值为: " + maxOptional.get());
        } else {
            System.out.println("流为空.");
        }
    }

输出结果

最小值为: 1
最大值为: 8

3.6 count

Stream 类的 count() 方法是用于计算流中元素个数的终端操作。它返回一个 long 类型的值，表示流中的元素数量。
count() 方法是一个终端操作，一旦调用该方法，流就被消耗，无法再次使用。

示例

   /** TODO **************************************  count **************************************  */

    public static void count() {
            List<Integer> numList = Arrays.asList(11, 22, 1, 2, 3, 4, 6, 33, 44, 553);
            long count = numList.stream().filter(s1 -> s1 > 10).count();
            System.out.println("大于10的个数数是：" + count);
    }

输出结果

大于10的个数数是：5

3.7 anyMatch / allMatch / noneMatch

Stream 类的 anyMatch(), allMatch(), 和 noneMatch() 是用于检查流中元素是否满足特定条件的终端操作。
它们返回一个布尔值，表示流中的元素是否满足指定的条件。这些方法在遇到满足条件的元素后可能会提前终止流的处理。

anyMatch检查是否有任意元素满足条件
allMatch检查是否所有元素都满足条件
noneMatch检查是否没有元素满足条件。

示例

  /**
     * TODO **************************************  anyMatch / allMatch / noneMatch **************************************
     */

    public static void matchTest() {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用anyMatch()检查是否存在元素大于5
        boolean anyGreaterThan5 = integerStream.anyMatch(num -> num > 4);
        System.out.println("是否存在元素大于 5 ?" + anyGreaterThan5);

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用allMatch()检查是否所有元素都小于10
        boolean allLessThan10 = newIntegerStream.allMatch(num -> num < 10);
        System.out.println("所有元素都小于10 ? " + allLessThan10);

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newestIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用noneMatch()检查是否没有元素等于10
        boolean noneEqualTo10 = newestIntegerStream.noneMatch(num -> num == 10);
        System.out.println("是否没有元素等于 10 ? " + noneEqualTo10);
    }

输出结果

是否存在元素大于 5 ?true
所有元素都小于10 ? true
是否没有元素等于 10 ? true

3.8 findFirst / findAny

Stream 类的 findFirst() 和 findAny() 方法用于在流中查找元素的终端操作.

它们都返回一个 Optional 对象，表示找到的元素或元素的可能性。
在并行流中，findAny() 方法可能更快，因为它不一定要遍历所有元素。
在串行 Stream 中，findFirst()和 findAny() 返回的是相同的元素，
在并行Stream中，findAny()返回的是最先找到的元素。

示例

假设我们有一个包含整数的流，并且我们想查找其中的某个元素。

   /**
     * TODO **************************************  findFirst / findAny **************************************
     */

    public static void FindStreamTest () {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用findFirst()找到第一个元素
        Optional<Integer> firstElementOptional = integerStream.findFirst();
        if (firstElementOptional.isPresent()) {
            System.out.println("发现第一个元素: " + firstElementOptional.get());
        } else {
            System.out.println("流为空!");
        }

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用findAny()找到任意一个元素
        Optional<Integer> anyElementOptional = newIntegerStream.findAny();
        if (anyElementOptional.isPresent()) {
            System.out.println("找到任意一个元素: " + anyElementOptional.get());
        } else {
            System.out.println("流为空!");
        }
    }

输出结果

发现第一个元素: 1
找到任意一个元素: 1

程序员小菜鸡QAQ

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【Java】常用Stream API

常用Stream API
复制链接

扫一扫

专栏目录

【Java】常用Stream API

常见 Stream 流表达式

一、两大类型

二、中间操作

2.1 filter

2.2 map

2.3 flatMap

2.4 sorted

2.5 distinct

2.6 limit

2.7 skip

2.8 peek

三、终端操作

3.1 forEach

3.2 collect

3.3 toArray

3.4 reduce

3.5 min / max

3.6 count

3.7 anyMatch / allMatch / noneMatch

3.8 findFirst / findAny

“相关推荐”对你有帮助么？