java Stream流使用方法全明白

已于 2022-05-19 11:18:09 修改
阅读量1k 收藏 3
点赞数
文章标签： java 开发语言
于 2022-05-19 11:17:37 首次发布
原文链接：https://zhuanlan.zhihu.com/p/339038230
版权
本文详细介绍了Java 8 Stream流操作，包括数据筛选（filter & distinct）、切片（limit & skip）、映射(map)、匹配(anyMatch & allMatch)、查找(findAny & findFirst)、归约(reduce)以及收集器(Collectors)的应用。通过实例演示，展示了如何利用Stream提高代码简洁性和性能。
摘要由CSDN通过智能技术生成

Stream流的使用

流操作是Java8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。

同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是惰性 取值，只有等到用户真正需要结果的时候才会执行。并且对于现在调用的方法，本身都是一种高层次构件，与线程模型无关。因此在并行使用中，开发者们无需再去操 心线程和锁了。Stream内部都已经做好了。

如果刚接触流操作的话，可能会感觉不太舒服。其实理解流操作的话可以对比数据库操作。把流的操作理解为对数据库中 数据的查询操作
集合 = 数据表
元素 = 表中的每条数据
属性 = 每条数据的列
流API = sql查询
流操作详解
Stream流接口中定义了许多对于集合的操作方法，总的来说可以分为两大类：中间操作和终端操作。

中间操作：会返回一个流，通过这种方式可以将多个中间操作连接起来，形成一个调用链，从而转换为另外 一个流。除非调用链后存在一个终端操作，否则中间操作对流不会进行任何结果处理。
终端操作：会返回一个具体的结果，如boolean、list、integer等。

1、筛选

对于集合的操作，经常性的会涉及到对于集中符合条件的数据筛选，Stream中对于数据筛选两个常见的API： filter(过滤)、distinct(去重)

1.1基于filter()实现数据过滤

该方法会接收一个返回boolean的函数作为参数，终返回一个包括所有符合条件元素的流。

案例：获取所有年龄20岁以下的学生

public class FilterDemo {
    public static void main(String[] args) {
        
        //获取所有年龄20岁以下的学生
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));
        students.stream().filter(student -> student.getAge()<20);
    }
}

1.2基于distinct实现数据去重

public class DistinctDemo {
    public static void main(String[] args) {
        
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        integers.stream().distinct().collect(Collectors.toList());
        
    }
}

在distinct()内部是基于LinkedHashSet对流中数据进行去重，并终返回一个新的流。

2、切片

2.1基于limit()实现数据截取

该方法会返回一个不超过给定长度的流

案例：获取数组的前五位

public class LimitDemo {
​
    public static void main(String[] args) {
        //获取数组的前五位
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        integers.stream().limit(5);
       
    }
}

2.2基于skip()实现数据跳过

案例：从集合第三个开始截取5个数据

public class LimitDemo {
​
    public static void main(String[] args) {
        //从集合第三个开始截取5个数据
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        List<Integer> collect = integers.stream().skip(3).limit(5).collect(Collectors.toList());
        collect.forEach(integer -> System.out.print(integer+" "));
​
    }
}
 

结果：4 4 5 5 6
案例：先从集合中截取5个元素，然后取后3个

public class LimitDemo {
​
    public static void main(String[] args) {
        //先从集合中截取5个元素，然后取后3个
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        List<Integer> collect = integers.stream().limit(5).skip(2).collect(Collectors.toList());
        collect.forEach(integer -> System.out.print(integer+" "));
​
    }
}

结果：3 4 4

3、映射

在对集合进行操作的时候，我们经常会从某些对象中选择性的提取某些元素的值，就像编写sql一样，指定获取表 中特定的数据列

#指定获取特定列 SELECT name FROM student
在Stream API中也提供了类似的方法，map()。它接收一个函数作为方法参数，这个函数会被应用到集合中每一个 元素上，并终将其映射为一个新的元素。 案例：获取所有学生的姓名，并形成一个新的集合

public class MapDemo {
    public static void main(String[] args) {
​
        //获取所有学生的姓名，并形成一个新的集合
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));
​
        List<String> collect = students.stream().map(Student::getName).collect(Collectors.toList());
        collect.forEach(s -> System.out.print(s + " "));
    }
}

​

结果：张三 李四 王五 赵六

4、匹配

在日常开发中，有时还需要判断集合中某些元素是否匹配对应的条件，如果有的话，在进行后续的操作。在 Stream API中也提供了相关方法供我们进行使用，如anyMatch、allMatch等。他们对应的就是&&和||运算符。

4.1基于anyMatch()判断条件至少匹配一个元素

anyMatch()主要用于判断流中是否至少存在一个符合条件的元素，它会返回一个boolean值，并且对于它的操作， 一般叫做短路求值

案例：判断集合中是否有年龄小于20的学生

public class AnyMatchDemo {
​
    public static void main(String[] args) {
        //判断集合中是否有年龄小于20的学生
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));
​
        if(students.stream().anyMatch(student -> student.getAge() < 20)){
            System.out.println("集合中有年龄小于20的学生");
        }else {
            System.out.println("集合中没有年龄小于20的学生");
        }
    }
}

根据上述例子可以看到，当流中只要有一个符合条件的元素，则会立刻中止后续的操作，立即返回一个布尔值，无需遍历整个流。

4.2基于allMatch()判断条件是否匹配所有元素

allMatch()的工作原理与anyMatch()类似，但是anyMatch执行时，只要流中有一个元素符合条件就会返回true， 而allMatch会判断流中是否所有条件都符合条件，全部符合才会返回true

案例：判断集合所有学生的年龄是否都小于20

public class AllMatchDemo {
​
    public static void main(String[] args) {
        //判断集合所有学生的年龄是否都小于20
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));
​
        if(students.stream().allMatch(student -> student.getAge() < 20)){
            System.out.println("集合所有学生的年龄都小于20");
        }else {
            System.out.println("集合中有年龄大于20的学生");
        }
    }
}

​
源码解析：与anyMatch类似，只是其枚举参数的值为ALL

5、查找

对于集合操作，有时需要从集合中查找中符合条件的元素，Stream中也提供了相关的API，findAny()和 findFirst()，他俩可以与其他流操作组合使用。findAny用于获取流中随机的某一个元素，findFirst用于获取流中的 第一个元素。至于一些特别的定制化需求，则需要自行实现。

5.1基于findAny()查找元素

案例：findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束

public class FindAnyDemo {
    public static void main(String[] args) {
        //findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三1","M",true));
        students.add(new Student(1,18,"张三2","M",false));
        students.add(new Student(1,21,"张三3","F",true));
        students.add(new Student(1,20,"张三4","F",false));
        students.add(new Student(1,20,"张三5","F",false));
        students.add(new Student(1,20,"张三6","F",false));
        Optional<Student> student1 = students.stream().filter(student -> student.getSex().equals("F")).findAny();
        System.out.println(student1.toString());
    }
​
}

结果：Optional[Student{id=1, age=21, name='张三3', sex='F', isPass=true}]
此时我们将其循环100次

public class FindAnyDemo {
    public static void main(String[] args) {
        //findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三1","M",true));
        students.add(new Student(1,18,"张三2","M",false));
        students.add(new Student(1,21,"张三3","F",true));
        students.add(new Student(1,20,"张三4","F",false));
        students.add(new Student(1,20,"张三5","F",false));
        students.add(new Student(1,20,"张三6","F",false));
        for (int i = 0; i < 100; i++) {
            Optional<Student> student1 = students.stream().filter(student -> student.getSex().equals("F")).findAny();
            System.out.println(student1.toString());
        }
​
    }
​
}

结果：
在这里插入图片描述

由于数量较大，只截取了部分截图，全部都是一样的，不行的小伙伴可以自己测试一下

这时候我们改为串行流在执行一下

public class FindAnyDemo {
    public static void main(String[] args) {
        //findAny用于获取流中随机的某一个元素，并且利用短路在找到结果时，立即结束
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三1","M",true));
        students.add(new Student(1,18,"张三2","M",false));
        students.add(new Student(1,21,"张三3","F",true));
        students.add(new Student(1,20,"张三4","F",false));
        students.add(new Student(1,20,"张三5","F",false));
        students.add(new Student(1,20,"张三6","F",false));
        for (int i = 0; i < 100; i++) {
            Optional<Student> student1 = students.parallelStream().filter(student -> student.getSex().equals("F")).findAny();
            System.out.println(student1.toString());
        }
​
    }
​
}

​
结果：

在这里插入图片描述

总结：当为串行流且数据较少时，获取的结果一般为流中第一个元素，但是当为并流行的时候，则会随机获取。

5.2基于findFirst()查找元素

findFirst使用原理与findAny类似，只是它无论串行流还是并行流都会返回第一个元素，这里不做详解

6、归约

到现在截止，对于流的终端操作，我们返回的有boolean、Optional和List。但是在集合操作中，我们经常会涉及 对元素进行统计计算之类的操作，如求和、求大值、小值等，从而返回不同的数据结果。

6.1基于reduce()进行累积求和

案例：对集合中的元素求和

public class ReduceDemo {
    public static void main(String[] args) {
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        Integer reduce = integers.stream().reduce(0, (integer1, integer2) -> integer1 + integer2);
        System.out.println(reduce);
    }
}

 结果：53

在上述代码中，在reduce里的第一个参数声明为初始值，第二个参数接收一个lambda表达式，代表当前流中的两 个元素，它会反复相加每一个元素，直到流被归约成一个终结果

Integer reduce = integers.stream().reduce(0,Integer::sum);
优化成这样也是可以的。当然，reduce还有一个不带初始值参数的重载方法，但是要对返回结果进行判断，因为如果流中没有任何元素的话，可能就没有结果了。具体方法如下所示

   List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
        Optional<Integer> reduce = integers.stream().reduce(Integer::sum);
        if(reduce.isPresent()){
            System.out.println(reduce);
        }else {
            System.out.println("数据有误");
        }

T result = identity; 
for (T element : this stream){  
result = accumulator.apply(result, element) 
}
return result;

单个参数的reduce方法

可以按照下述代码进行理解：

boolean flag = false; 
T result = null; 
for (T element : this stream) { 
    if (!flag) { 
        flag = true;  
        result = element; 
    }else{  
        result = accumulator.apply(result, element); 
    } 
} 
return flag ? Optional.of(result) : Optional.empty();

6.2获取流中元素的最大值、最小值

案例：获取集合中元素的最大值、最小值

public class MaxDemo {
    public static void main(String[] args) {
​
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
​
        /**
         * 获取集合中的最大值
         */
        //方法一
        Optional<Integer> max1 = integers.stream().reduce(Integer::max);
        if(max1.isPresent()){
            System.out.println(max1);
        }
        //方法二
        Optional<Integer> max2 = integers.stream().max(Integer::compareTo);
        if(max2.isPresent()){
            System.out.println(max2);
        }
​
        /**
         * 获取集合中的最小值
         */
        //方法一 
        Optional<Integer> min1 = integers.stream().reduce(Integer::min);
        if(min1.isPresent()){
            System.out.println(min1);
        }
​
        //方法二
        Optional<Integer> min2 = integers.stream().min(Integer::compareTo);
        if(min2.isPresent()){
            System.out.println(min2);
        }
    }
}

结果：

Optional[8]
Optional[8]
Optional[1]
Optional[1]

7、收集器

通过使用收集器，可以让代码更加方便的进行简化与重用。其内部主要核心是通过Collectors完成更加复杂的计算 转换，从而获取到终结果。并且Collectors内部提供了非常多的常用静态方法，直接拿来就可以了。比方说： toList。

public class CollectDemo {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));
​
        //通过counting()统计集合总数  方法一
        Long collect = students.stream().collect(Collectors.counting());
        System.out.println(collect);
        //结果 4
​
        //通过count()统计集合总数  方法二
        long count = students.stream().count();
        System.out.println(count);
        //结果 4
​
        //通过maxBy求最大值
        Optional<Student> collect1 = students.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
        if(collect1.isPresent()){
            System.out.println(collect1);
        }
        //结果 Optional[Student{id=1, age=21, name='王五', sex='F', isPass=true}]
​
        //通过max求最大值
        Optional<Student> max = students.stream().max(Comparator.comparing(Student::getAge));
        if(max.isPresent()){
            System.out.println(max);
        }
        //结果  Optional[Student{id=1, age=21, name='王五', sex='F', isPass=true}]
​
        //通过minBy求最小值
        Optional<Student> collect2 = students.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));
        if(collect2.isPresent()){
            System.out.println(collect2);
        }
        //结果  Optional[Student{id=1, age=18, name='李四', sex='M', isPass=false}]
​
        //通过min求最小值
        Optional<Student> min = students.stream().min(Comparator.comparing(Student::getAge));
        if(min.isPresent()){
            System.out.println(min);
        }
        //结果  Optional[Student{id=1, age=18, name='李四', sex='M', isPass=false}]
​
        //通过summingInt()进行数据汇总
        Integer collect3 = students.stream().collect(Collectors.summingInt(Student::getAge));
        System.out.println(collect3);
        //结果 78
​
        //通过averagingInt()进行平均值获取
        Double collect4 = students.stream().collect(Collectors.averagingInt(Student::getAge));
        System.out.println(collect4);
        //结果 19.5
​
        //通过joining()进行数据拼接
        String collect5 = students.stream().map(Student::getName).collect(Collectors.joining());
        System.out.println(collect5);
        //结果 张三李四王五赵六
        
        //复杂结果的返回
        IntSummaryStatistics collect6 = students.stream().collect(Collectors.summarizingInt(Student::getAge));
        double average = collect6.getAverage();
        long sum = collect6.getSum();
        long count1 = collect6.getCount();
        int max1 = collect6.getMax();
        int min1 = collect6.getMin();
        
    }
​
}

8、分组

在数据库操作中，经常会通过group by对查询结果进行分组。同时在日常开发中，也经常会涉及到这一类操作， 如通过性别对学生集合进行分组。如果通过普通编码的方式需要编写大量代码且可读性不好。

对于这个问题的解决，java8也提供了简化书写的方式。通过 Collectors。groupingBy()即可。

//通过性别对学生进行分组

        Map<String, List<Student>> collect = students.stream().collect(Collectors.groupingBy(Student::getSex));
结果  {
    F=[Student{id=1, age=21, name='王五', sex='F', isPass=true}, Student{id=1, age=20, name='赵六', sex='F', isPass=false}],
    M=[Student{id=1, age=19, name='张三', sex='M', isPass=true}, Student{id=1, age=18, name='李四', sex='M', isPass=false}]
}

8.1多级分组

刚才已经使用groupingBy()完成了分组操作，但是只是通过单一的sex进行分组，那现在如果需求发生改变，还要 按照是否及格进行分组，能否实现？答案是可以的。对于groupingBy()它提供了两个参数的重载方法，用于完成这 种需求。

这个重载方法在接收普通函数之外，还会再接收一个Collector类型的参数，其会在内层分组(第二个参数)结果，传 递给外层分组(第一个参数)作为其继续分组的依据。

//现根据是否通过考试对学生分组，在根据性别分组     
Map<String, Map<Boolean, List<Student>>> collect1 = students.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getPass)));
结果： {
    F={
        false=[Student{id=1, age=20, name='赵六', sex='F', isPass=false}],
        true=[Student{id=1, age=21, name='王五', sex='F', isPass=true}]
    }, 
    M={
        false=[Student{id=1, age=18, name='李四', sex='M', isPass=false}], 
        true=[Student{id=1, age=19, name='张三', sex='M', isPass=true}]}
}
​

8.2多级分组变形

在日常开发中，我们很有可能不是需要返回一个数据集合，还有可能对数据进行汇总操作，比方说对于年龄18岁 的通过的有多少人，未及格的有多少人。因此，对于二级分组收集器传递给外层分组收集器的可以任意数据类型， 而不一定是它的数据集合。

//根据年龄进行分组，获取并汇总人数
        Map<Integer, Long> collect2 = students.stream().collect(Collectors.groupingBy(Student::getAge, Collectors.counting()));
        System.out.println(collect2);
​
结果：{18=1, 19=1, 20=1, 21=1}

//要根据年龄与是否及格进行分组，并获取每组中年龄的学生
        Map<Integer, Map<Boolean, Student>> collect3 = students.stream().collect(Collectors.groupingBy(Student::getAge, Collectors.groupingBy(Student::getPass,
                Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparing(Student::getAge)), Optional::get))));
        System.out.println(collect3.toString());
结果：{
    18={false=Student{id=1, age=18, name='李四', sex='M', isPass=false}},
    19={true=Student{id=1, age=19, name='张三', sex='M', isPass=true}},
    20={false=Student{id=1, age=20, name='赵六', sex='F', isPass=false}}, 
    21={true=Student{id=1, age=21, name='王五', sex='F', isPass=true}}}

声明
本文为转载文章，仅供个人学习使用

原文作者：我是七月呀

原文链接：https://zhuanlan.zhihu.com/p/339038230

向来枉费推移力
关注
JAVA中的Stream流的使用详解
2302_79993788的博客
08-23 902
下面我们来举个例子来感受一下Stream有多优雅Stream的类型我们可以对流进行中间操作或者终端操作。小伙伴们可能会疑问？
Java基础之Stream流
何小白的博客
06-13 417
Stream流的基本使用
Java 中 Stream 流的使用方法
qq_58417838的博客
12-25 2357
返回一个顺序流，即元素是按顺序处理的。这意味着对于大多数操作，它们将按照集合中元素的顺序依次执行。1.1、通过Collection对象的stream()或parallelStream()方法。1.4、通过IntStream、LongStream、DoubleStream接口中的of、1.3、通过Stream接口的of()、iterate()、generate()方法。使用一个终止操作来产生一个结果（新的对象）。该操作会强制之前的延迟操作立即执行，在此之后，该。操作是延迟执行的，会等到需要结果的时候才执行。
Java Stream常见用法汇总，开发效率大幅提升
程序员小明1024
01-19 792
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(37, 41, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
Java Stream流的使用
Twilight's Blog
10-27 520
流相关的方法可以分为三种类型，分别是：获取Stream流、中间方法、终结方法。中间方法会返回当前流，可以方便的进行链式调用。| 把元素收集到List集合中 || 把元素收集到Set集合中 || 把元素收集到Map集合中 || 把元素收集到数组中 |
Java8新特性Stream流的概念和使用【详解】
weixin_65657777的博客
05-24 3998
🎉博客首页：痛而不言笑而不语的浅伤 📢欢迎关注🥳点赞 👍 收藏 ⭐留言 📝 欢迎讨论！ 🔮本文由痛而不言笑而不语的浅伤原创，CSDN首发！ 🌋系列专栏：《JavaSE系列详解》 🧿首发时间：2022年5月24日 ❤：热爱Java学习，期待一起交流！ 🙏🏻作者水平有限，如果发现错误，求告知，多谢！ 🥰有问题可以私信交流！！！ 目录 引言 Stream流的概念 为什么要使用Stream流？ Stream的两个基础的特征: Stream流的获取 通过Collection集合获取.
Java Stream中reduce方法的使用
kouzhaokui的博客
05-24 3382
三种重载的方法 第一种 Optional<T> reduce(BinaryOperator<T> accumulator); 方法接受一个BinaryOperator类型的lambada表达式， 常规应用方法如下： List<Integer> list = Arrays.asList(1,2,3,4); int result = list.stream().reduce((a,b) -> a+b).get(); System.out.println(r
SpringBoot实践（九）：Java8流处理stream与completableFuture异步编程
叶子叶来
09-06 4971
流处理stream结合函数式编程规范，极大提升编程效率，减少代码量，而异步编程completableFuture的使用，则能够更加清晰地表述出业务逻辑，方法的异步调用关系路径很好滴描述了业务脉络； Stream 这里先构造2个对象，student和teacher，teacher拥有多个student对象，经常有类似使用teacher对象后对student操作的场景，使用流处理比for、foreach、Iterator更优雅；......
JAVA 自定义解析stream_Java 8之自定义Stream收集器
weixin_33794626的博客
03-05 880
声明：本篇文章除部分引用外，均为原创内容，如有雷同纯属巧合，引用转载请附上原文链接与声明本文链接：注：阅读本篇文章需掌握java集合基础知识、Stream基本语法与使用、函数式接口、lambda表达式、泛型知识、lombok插件使用、guava基础集合工具使用、java8双冒号的使用；请先掌握上述知识再行阅读本篇文章。若有错误，欢迎友好纠正，谢谢。参考引用文章大纲Stream基础收集功能演示Str...
Lambda表达式九：Stream流三：Stream常用方法；
小枯林的博客
04-25 2122
大 案例1：提取集合中所有偶数并求和：mapToInt()方法，filter()方法，sum()方法； package com.imooc.stream; import org.junit.Test; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class StreamMethod {
Java的Stream流使用
qq_33801738的博客
08-08 381
##为什么需要 Stream Stream作为 Java 8的一大亮点，它与 java.io 包里的 InputStream和 OutputStream是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行...
Java Stream流基本使用方法
weixin_67898144的博客
04-17 1928
近期看到Java的Stream流操作，简直是一整个迷上了，简简单单的几行代码就可以完成对集合或数组的处理，但是我又不怎么会，那我今天就来总结一下Java中Stream流操作的基础用法吧。注意，只适合小白阅读，因为我也是个小白~
Java Stream流使用
qq_31101675的博客
12-11 606
What - 是什么 Stream 是JDK8 引入的一个 流 的概念，这个流不同于 IO中输入和输出流，这个流主要作用是将数组和集合由非Stream流对象转换成Stream对象，这个类在java.util.stream.Stream下，主要操作符分为三种：获取流、中间操作、终止操作。 Stream 给人的感觉就是一种用SQL语句从数据库查询数据的方式对Java集合运算、排序、过滤等操作的高阶操作。 以下来自官方解释： Stream（流）是一个来自数据源的元素队列并支持聚
JavaStream流的使用
最新发布
qq_50477101的博客
09-02 775
Stream流
java的stream流方法
baidu_41564215的博客
09-15 267
一、流程： stream of elements -> filter -> sorted -> map -> collect 二、java格式 List<Integer> transactionsIds = widgets.stream() .filter(b -> b.getColor() == RED) .sorted((x,y) -> x.getWeight() - y.getWeight())
java Stream()流的使用
Cloud
07-15 1001
java Stream()流的使用
Java stream流的使用、详解
m0_56926842的博客
08-30 504
stream流是jdk8的新增特性，为的就是方便对集合、数组的操作。流，其实可以理解成工厂的流水线，在流水线上，会对物品进行各种操作。java中流的思想与这个一样，我们会先对数据（集合、数组）开启流（相当与是将数据放在流水线上），然后调用过滤方法（对数据进行操作），最后调用终结方法（对剩余的数据进行输出操作）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值