Java8 Stream 常用方法大合集

最新推荐文章于 2024-05-28 17:40:39 发布
最新推荐文章于 2024-05-28 17:40:39 发布
阅读量580 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhq1033/article/details/125778065
版权

相信Java8的Stream 大家都已听说过了，但是可能大家不会用或者用的不熟，文章将带大家从零开始使用，循序渐进，带你走向Stream的巅峰。

操作符

什么是操作符呢？操作符就是对数据进行的一种处理工作，一道加工程序；就好像工厂的工人对流水线上的产品进行一道加工程序一样。

Stream的操作符大体上分为两种：中间操作符和终止操作符

中间操作符

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符。

中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作)：

  • map(mapToInt,mapToLong,mapToDouble) 转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。

  • flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平 变成 2，3，4 也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。

  • limit 限流操作，比如数据流中有10个 我只要出前3个就可以使用。

  • distint 去重操作，对重复元素去重，底层使用了equals方法。

  • filter 过滤操作，把不想要的数据过滤。

  • peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。

  • skip 跳过操作，跳过某些元素。

  • sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

终止操作符

数据经过中间加工操作，就轮到终止操作符上场了；终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。

  • collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。

  • count 统计操作，统计最终的数据个数。

  • findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。

  • noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素 返回值为bool 值。

  • min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。

  • reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。

  • forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。

  • toArray 数组操作，将数据流的元素转换成数组。

这里只介绍了Stream，并没有涉及到IntStream、LongStream、DoubleStream，这三个流实现了一些特有的操作符，我将在后续文章中介绍到。

说了这么多，只介绍这些操作符还远远不够；俗话说，实践出真知。那么，Let‘s go。

代码演练

Stream 的一系列操作必须要使用终止操作，否者整个数据流是不会流动起来的，即处理操作不会执行。

  • map，可以看到 map 操作符要求输入一个Function的函数是接口实例，功能是将T类型转换成R类型的。

map操作将原来的单词 转换成了每个单的长度，利用了String自身的length()方法，该方法返回类型为int。这里我直接使用了lambda表达式，关于lambda表达式 还请读者们自行了解吧。

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of("apple","banana","orange","waltermaleon","grape")  
                .map(e->e.length()) //转成单词的长度 int  
                .forEach(e->System.out.println(e)); //输出  
    }  
}  

当然也可以这样，这里使用了成员函数引用，为了便于读者们理解，后续的例子中将使用lambda表达式而非函数引用。

public class Main {  
  
    public static void main(String[] args) {  
         Stream.of("apple","banana","orange","waltermaleon","grape")  
                .map(String::length) //转成单词的长度 int  
                .forEach(System.out::println);  
    }  
}  

结果如图：

  • mapToInt 将数据流中得元素转成Int，这限定了转换的类型Int，最终产生的流为IntStream，及结果只能转化成int。

public class Main {  
  
    public static void main(String[] args) {  
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .mapToInt(e -> e.length()) //转成int  
                .forEach(e -> System.out.println(e));  
    }  
}  

mapToInt如图：

玩转Java8中的 Stream 之从零认识 Stream

  • mapToLong、mapToDouble 与mapToInt 类似

public class Main {  
  
    public static void main(String[] args) {  
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .mapToLong(e -> e.length()) //转成long ,本质上是int 但是存在类型自动转换  
                .forEach(e -> System.out.println(e));  
    }  
}  

mapToLong 如图：

public class Main {  
  
    public static void main(String[] args) {  
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .mapToDouble(e -> e.length()) //转成Double ，自动类型转换成Double  
                .forEach(e -> System.out.println(e));  
    }  
}  

mapToDouble如图：

  • flatmap 作用就是将元素拍平拍扁 ，将拍扁的元素重新组成Stream，并将这些Stream 串行合并成一条Stream

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of("a-b-c-d","e-f-i-g-h")  
                .flatMap(e->Stream.of(e.split("-")))  
                .forEach(e->System.out.println(e));  
  
    }  
}  

flatmap 如图：

  • flatmapToInt、flatmapToLong、flatmapToDouble 跟flatMap 都类似的，只是类型被限定了，这里就不在举例子了。

  • limit 限制元素的个数，只需传入 long 类型 表示限制的最大数

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of(1,2,3,4,5,6)  
                .limit(3) //限制三个  
                .forEach(e->System.out.println(e)); //将输出 前三个 1，2，3  
    }  
}  

limit如图：

public class Main {  
  
    public static void main(String[] args) {  
  
        Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)  
                .distinct() //去重  
                .forEach(e->System.out.println(e));  
  
    }  
}  

distinct 如图：

  • filter 对某些元素进行过滤，不符合筛选条件的将无法进入流的下游

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)  
                .filter(e->e>=5) //过滤小于5的  
                .forEach(e->System.out.println(e));  
    }  
}  

filter 如图：

  • peek 挑选 ，将元素挑选出来，可以理解为提前消费

public class Main {  
  
    public static void main(String[] args) {  
  
        User w = new User("w",10);  
        User x = new User("x",11);  
        User y = new User("y",12);  
  
        Stream.of(w,x,y)  
                .peek(e->{e.setName(e.getAge()+e.getName());}) //重新设置名字 变成 年龄+名字  
                .forEach(e->System.out.println(e.toString()));  
  
    }  
  
    static class User {  
  
        private String name;  
  
        private int age;  
  
        public User(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  
  
        public String getName() {  
            return name;  
        }  
  
        public void setName(String name) {  
            this.name = name;  
        }  
  
        public int getAge() {  
            return age;  
        }  
  
        public void setAge(int age) {  
            this.age = age;  
        }  
  
        @Override  
        public String toString() {  
            return "User{" +  
                    "name='" + name + ''' +  
                    ", age=" + age +  
                    '}';  
        }  
    }  
  
}  

peek 如图：

  • skip 跳过 元素

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of(1,2,3,4,5,6,7,8,9)  
                .skip(4) //跳过前四个  
                .forEach(e->System.out.println(e)); //输出的结果应该只有5，6，7，8，9  
    }  
}  

skip 如图：

  • sorted 排序 底层依赖Comparable 实现，也可以提供自定义比较器

这里Integer 实现了比较器

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of(2,1,3,6,4,9,6,8,0)  
                .sorted()  
                .forEach(e->System.out.println(e));  
    }  
}  

sorted 默认比较器如图： 

这里使用自定义比较，当然User 可以实现Comparable 接口

public class Main {  
  
    public static void main(String[] args) {  
  
        User x = new User("x",11);  
        User y = new User("y",12);  
        User w = new User("w",10);  
  
        Stream.of(w,x,y)  
                .sorted((e1,e2)->e1.age>e2.age?1:e1.age==e2.age?0:-1)  
                .forEach(e->System.out.println(e.toString()));  
  
    }  
  
    static class User {  
  
        private String name;  
  
        private int age;  
  
        public User(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  
  
        public String getName() {  
            return name;  
        }  
  
        public void setName(String name) {  
            this.name = name;  
        }  
  
        public int getAge() {  
            return age;  
        }  
  
        public void setAge(int age) {  
            this.age = age;  
        }  
  
        @Override  
        public String toString() {  
            return "User{" +  
                    "name='" + name + ''' +  
                    ", age=" + age +  
                    '}';  
        }  
    }  
  
}  

如图：

玩转Java8中的 Stream 之从零认识 Stream

  • collect 收集，使用系统提供的收集器可以将最终的数据流收集到List，Set，Map等容器中。

这里我使用collect 将元素收集到一个set中

public class Main {  
  
    public static void main(String[] args) {  
        Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .collect(Collectors.toSet()) //set 容器  
                .forEach(e -> System.out.println(e));  
    }  
}  

咦？，不是说终止操作符只能使用一次吗，为什么这里调用了forEach 呢？forEach不仅仅是是Stream 中得操作符还是各种集合中得一个语法糖，不信咋们试试。

public class Main {  
  
    public static void main(String[] args) {  
  
        Set<String> stringSet = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .collect(Collectors.toSet()); //收集的结果就是set  
        stringSet.forEach(e->System.out.println(e)); set的语法糖forEach  
}  

结果如图：

  • count 统计数据流中的元素个数，返回的是long 类型

public class Main {  
  
    public static void main(String[] args) {  
  
        long count = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .count();  
  
        System.out.println(count);  
    }  
}  

count 如图：

  • findFirst 获取流中的第一个元素

这里找到第一个元素 apple

public class FindFirst {  
  
    public static void main(String[] args) {  
        Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .findFirst();  
        stringOptional.ifPresent(e->System.out.println(e));  
    }  
}  

findFirst 结果如图：

  • findAny 获取流中任意一个元素

public class FindAny {  
  
    public static void main(String[] args) {  
        Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")  
                .parallel()  
                .findAny(); //在并行流下每次返回的结果可能一样也可能不一样  
        stringOptional.ifPresent(e->System.out.println(e));  
    }  
}  

findAny 在并行流下 使用结果：

输出了orange

输出了banana

  • noneMatch 数据流中得没有一个元素与条件匹配的

这里 的作用是是判断数据流中 一个都没有与aa 相等元素 ，但是流中存在 aa ，所以最终结果应该是false

public class NoneMatch {  
  
    public static void main(String[] args) {  
        boolean result = Stream.of("aa","bb","cc","aa")  
                .noneMatch(e->e.equals("aa"));  
        System.out.println(result);  
    }  
}  

noneMatch 如图：

  • allMatch和anyMatch 一个是全匹配，一个是任意匹配 和noneMatch 类似，这里就不在举例了。

  • min 最小的一个，传入比较器，也可能没有(如果数据流为空)

public class Main {  
  
    public static void main(String[] args) {  
  
        Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)  
                .min((e1,e2)->e1.compareTo(e2));  
  
        integerOptional.ifPresent(e->System.out.println(e));  
  
    }  

min如图：

  • max 元素中最大的，需要传入比较器，也可能没有（流为Empty时）

public class Main {  
  
    public static void main(String[] args) {  
  
        Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)  
                .max((e1,e2)->e1.compareTo(e2));  
  
        integerOptional.ifPresent(e->System.out.println(e));  
  
    }  
}  

max 如图：

  • reduce 是一个规约操作，所有的元素归约成一个，比如对所有元素求和，乘啊等。

这里实现了一个加法，指定了初始化的值

public class Main {  
    public static void main(String[] args) {  
  
        int sum = Stream.of(0,9,8,4,5,6,-1)  
              .reduce(0,(e1,e2)->e1+e2);  
        System.out.println(sum);  
    }  
}  

reduce 如图：

  • forEach

forEach 其实前就已经见过了，对每个数据遍历迭代

  • forEachOrdered 适用用于并行流的情况下进行迭代，能保证迭代的有序性

这里通过并行的方式输出数字

public class ForEachOrdered {  
    public static void main(String[] args) {  
        Stream.of(0,2,6,5,4,9,8,-1)  
                .parallel()  
                .forEachOrdered(e->{  
                    System.out.println(Thread.currentThread().getName()+": "+e);});  
    }  
}  

forEachOrdered 如图：

  • toArray 转成数组，可以提供自定义数组生成器

public class ToArray {  
    public static void main(String[] args) {  
        Object[] objects=Stream.of(0,2,6,5,4,9,8,-1)  
                .toArray();  
  
        for (int i = 0; i < objects.length; i++) {  
            System.out.println(objects[i]);  
        }  
    }  
}  

toArray 如图：

小金很忙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java8 stream使用总结
08-16
Java 8是Java发展历程中的一个重要里程碑，它引入了许多新特性，其中最为显著的就是Stream API。Stream API彻底改变了我们处理集合数据的方式，使得代码更加简洁、高效且易于理解。以下是对"Java 8 Stream使用总结...
详解java8中的Stream数据流
08-29
Java 8 中的 Stream 数据流是一种高效、简洁的数据处理方式，使用 lambda 表达式和方法引用来实现数据处理。Stream 支持多种数据处理方式，包括 filter、map、reduce 等操作，灵活性强，适合多种业务需求。
java stream流处理字段（BigDecimal类型）相加
weixin_49286764的博客
04-25 2601
java stream流处理字段（BigDecimal类型）相加。
Java8 Stream 常用方法大合集，代码更优雅了！
Java笔记虾
07-12 270
点击关注公众号，利用碎片时间学习相信Java8的Stream 大家都已听说过了，但是可能大家不会用或者用的不熟，文章将带大家从零开始使用，循序渐进，带你走向Stream的巅峰。操作符什么是操作符呢？操作符就是对数据进行的一种处理工作，一道加工程序；就好像工厂的工人对流水线上的产品进行一道加工程序一样。Stream的操作符大体上分为两种：中间操作符和终止操作符中间操作符对于...
Java 8新特性Stream的常用方法总结和使用
最新发布
weixin_44625361的博客
05-28 810
Stream 是 Java 8 引入的一个新的流式处理 API，用于对集合进行高效的操作和处理。Stream 提供了一系列方法，使得对集合的操作更加简洁、高效和易于理解Stream API提供了一种高效且易于阅读的方式来操作数据，特别是在需要对数据进行过滤、映射、排序、聚合等操作时。
Java对象Stream操作：排重、排序、相加
迷迷糊糊，懵懵懂懂
12-28 900
在Java中，Stream API提供了一种优雅而强大的方式来处理集合数据。在本文中，我们将探讨如何使用Java的Stream对对象集合进行排重、排序和相加等操作，以及一些示例代码演示。
java 两个二维数组相加用stream流处理
weixin_35749440的博客
01-16 1036
可以使用Java 8 Stream API将两个二维数组相加。 首先，将两个二维数组转换成一维数组，使用flatMap()函数将二维数组转换成一维数组。然后使用mapToInt()函数将一维数组中的每个元素转换成一个IntStream。最后使用sum()函数计算总和。 示例代码如下： int[][] array1 = {{1, 2, 3}, {4, 5, 6}}; int[][] array2 =...
java8--Stream
李小狼
12-06 166
package com.example.demo.java8; import java.awt.*; import java.util.*; import java.util.List; import java.util.function.IntBinaryOperator; import java.util.stream.IntStream; import java.util.stream....
如何在java 8 map中使用stream
08-19
Java 8 中使用 Stream 遍历 Map Java 8 中引入了 Stream 概念， Stream 是一种非常强大的功能，可以使我们更加简单的操作 Map 对象。Map 是 Java 中非常常用的一个集合类型，我们通常也需要去遍历 Map 去获取某些值...
怎么break java8 stream的foreach
12-21
在 Java 8 中，虽然 `forEach` 默认不支持中途退出，但通过自定义 `Spliterator` 或自定义 `forEach` 方法，我们可以实现类似 `break` 的效果，灵活控制 Stream 遍历的结束条件。这种方式在处理大量数据或无限流时...
Java8处理集合的优雅姿势之Stream
08-26
在Java 8中，可以有多种方法来创建流，以下是常用的方法： * 通过已有的集合来创建流：可以使用集合的stream方法将一个集合转换成流。 * 通过Stream创建流：可以使用Stream类提供的方法，直接返回一个由指定元素...
java8 stream 累加_使用java8的stream对数组进行求和
weixin_39655085的博客
02-13 4502
1.对BigDecimal类型的值求和List> list = new ArrayList<>();Map stu1 = new HashMap();stu1.put("name", "卫庄");stu1.put("score", new BigDecimal(80));list.add(stu1);Map stu2 = new HashMap();stu2.put("name"...
java 使用stream累加对象中某个属性的值并返回总和
热门推荐
原&点、、
03-29 2万+
假设有一个包含对象的List列表，每个对象都有一个属性value，可以使用Java 8中的Stream流来累加对象中某个属性的值并返回总和。
stream流对集合的数进行相加
qq_50990884的博客
03-01 816
stream流对集合的数进行相加。
Stream流的求和 ，int 、double、 BigDecimal 三种类型的求和
咸鱼爸爸的博客
12-14 1万+
搞一下int 、double、 BigDecimal 三种类型的求和。 public static class User{ private int age;//年龄 private BigDecimal price;//金额 private double score;//评分 public int getAge() { return age; } public void setAg
Java8 stream 流的用法
weixin_42405132的博客
02-23 876
9、条件匹配：allMatch、anyMatch、noneMatch System.out.println(stream.allMatch(s -> s.length() > 2));11、获取最大最小值：max、min Optional max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);8、去重：distinct stream.distinct().forEach(System.out::println);
JAVA8 Stream流
wenwen0209的博客
03-26 697
【代码】JAVA8 Stream流。
stream流运算：求和（基本数据类型，BigDecimal），多字段乘积求和，提取对象属性集合
poker_zero的博客
08-25 4583
stream流运算：求和（基本数据类型，BigDecimal），多字段乘积求和，提取对象属性集合
java中各种类型用Stream流求和
拒绝熬夜啊的博客
01-20 5692
java中各种类型用Stream流求和
java8 stream常用方法
03-03
Java 8引入了Stream API，它提供了一种更简洁、更灵活的方式来处理集合数据。下面是Java 8 Stream常用的方法： 1. filter(Predicate<T> predicate)：根据指定条件过滤出符合条件的元素。 2. map(Function<T, R> mapper)：将每个元素通过指定的映射函数转换成另一个元素。 3. flatMap(Function<T, Stream<R>> mapper)：将每个元素通过指定的映射函数转换成一个流，并将所有流连接成一个流。 4. distinct()：去除流中重复的元素。 5. sorted()：对流中的元素进行排序，默认按照自然顺序排序。 6. limit(long maxSize)：截取流中的前N个元素。 7. skip(long n)：跳过流中的前N个元素。 8. forEach(Consumer<T> action)：对流中的每个元素执行指定操作。 9. collect(Collector<T, A, R> collector)：将流中的元素收集到一个结果容器中。 10. reduce(BinaryOperator<T> accumulator)：将流中的元素依次进行指定的二元操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值