Java8中Stream()流的用法总结

简单的集合遍历

foreach遍历

import java.util.ArrayList;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class Demo1Foreach {

    public static void main(String[] args) {

        List<String>list=new ArrayList<>();

        list.add("w2");

        list.add("zh3");

        list.add("l4");

        list.add("lao6");

        list.add("tomas");

        for (String s:list){

            System.out.println(s);

        }

    }

}

　　迭代器遍历

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class Demo1Foreach {

    public static void main(String[] args) {

        List<String>list=new ArrayList<>();

        list.add("w2");

        list.add("zh3");

        list.add("l4");

        list.add("lao6");

        list.add("tomas");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()){

            System.out.println(iterator.next()+"\t");

        }

    }

}

　有以下场景

将集合A根据条件一过滤为子集B；
然后再根据条件二过滤为子集C。

先使用Java8以前的做法

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.stream.Collectors;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class Demo1Foreach {

    public static void main(String[] args) {

        List<String>list=new ArrayList<>();

        List<String>listA=new ArrayList<>();

        List<String>listB=new ArrayList<>();

        list.add("w2");

        list.add("zh3");

        list.add("l4");

        list.add("lao6");

        list.add("tomas");

       for (String s:list){

           if (s.startsWith("l")){

               listA.add(s);

           }

       }

       for (String s:listA){

           if (s.length()==4){

               listB.add(s);

           }

       }

        for (String s:listB){

            System.out.println(s);

        }

    }

}

　　使用Stream()流更优的写法

1.场景一：筛选

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

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

import jdk.nashorn.internal.ir.IfNode;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.stream.Collectors;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class StreamDemo1 {

    public static void main(String[] args) {

        List<String>list=new ArrayList<>();

        List<String>listA=new ArrayList<>();

        List<String>listB=new ArrayList<>();

        list.add("w2");

        list.add("zh3");

        list.add("l4");

        list.add("lao6");

        list.add("tomas");

       list.stream().filter(

               name->name.startsWith("l")

       ).filter(

               name->name.length()==4

       ).forEach(name-> System.out.println(name));

    }

}

import jdk.nashorn.internal.ir.IfNode;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class StreamDemo2 {

    public static void main(String[] args) {

        List<Student>students=new ArrayList<>();

        students.add(new Student("wang2",5,"f"));

        students.add(new Student("zh3",3,"f"));

        students.add(new Student("li4",5,"f"));

         students.stream().filter(student ->

                student.getName().length() == 3

                        && student.getAge() < 5

        ).forEach(System.out::println);

    }

}

class Student {

    public Student(String name, int age, String gender) {

        this.name = name;

        this.age = age;

        this.gender = gender;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "Student{" +

                "name='" + name + '\'' +

                ", age=" + age +

                ", gender='" + gender + '\'' +

                '}';

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getGender() {

        return gender;

    }

    public void setGender(String gender) {

        this.gender = gender;

    }

    private String name;

    private int age;

    private String gender;

}

　1.2基于distinct实现数据去重

import java.util.Arrays;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/3 10:04

 */

public class StreamDemo3 {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 4, 5, 3, 2, 1, 3, 4, 5, 6, 5, 7, 8);

        numbers.stream().distinct().forEach(System.out::println);

    }

}

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

2.切片

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

import java.util.Arrays;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/3 10:04

 */

public class StreamDemo5 {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 4, 5, 3, 2, 1, 3, 4, 5, 6, 5, 7, 8);

        numbers.stream().limit(3).forEach(System.out::println);

    }

}

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

import java.util.Arrays;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/3 10:04

 */

public class StreamDemo6 {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 4, 5, 3, 2, 1, 3, 4, 5, 6, 5, 7, 8);

        numbers.stream().skip(3).forEach(System.out::println);

    }

}

　3.映射

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

public class StreamDemo7 {

    public static void main(String[] args) {

        List<Student>students=new ArrayList<>();

        students.add(new Student("wang2",5,"f"));

        students.add(new Student("zh3",3,"f"));

        students.add(new Student("li4",5,"f"));

        List<String> stringList = students.stream().map(student -> student.getName()).collect(Collectors.toList());

        stringList.stream().forEach(System.out::println);

    }

}

4、匹配

boolean anyMatch()、boolean allMatch()、boolean noneMatch()方法。

import jdk.nashorn.internal.ir.IfNode;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class StreamDemo8 {

    public static void main(String[] args) {

        List<Student>students=new ArrayList<>();

        students.add(new Student("wang2",5,"f"));

        students.add(new Student("zh3",3,"f"));

        students.add(new Student("li4",5,"f"));

if (students.stream().allMatch(student -> student.getAge()<5)){

    System.out.println("have ");

        }else {

    System.out.println("don't");

}

    }

}

5.查找

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

5.1基于ﬁndAny()查找元素

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

public class StreamDemo9 {

    public static void main(String[] args) {

        List<Student>students=new ArrayList<>();

        students.add(new Student("wang2",5,"f"));

        students.add(new Student("zh3",3,"f"));

        students.add(new Student("li4",5,"f"));

        Optional<Student> optionalStudent = students.stream().filter(student -> student.getName().length() == 3).findAny();

        System.out.println(optionalStudent.toString());

    }

}

5.2基于ﬁndFirst()查找元素

ﬁndFirst使用原理与findAny类似，只是它无论串行流还是并行流都会返回第一个元素

6、归约

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

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

import java.util.Arrays;

import java.util.List;

/**

 * @author rx

 * @date 2022/6/3 13:34

 */

public class StreamDemo10 {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        Integer reduce = list.stream().reduce(0, (x1, x2) -> x1 + x2);

        System.out.println(reduce);

    }

}

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

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

/**

 * @author rx

 * @date 2022/6/3 13:34

 */

public class StreamDemo11 {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        Optional<Integer> reduce = list.stream().reduce(Integer::sum);

        if (reduce.isPresent()){

            System.out.println(reduce);

        }else

            System.out.println("data is error");

    }

}

6.2 获取流中的最大值最小值

public class StreamDemo12 {

    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);

        }

    }

}

7、收集器

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

import jdk.nashorn.internal.ir.IfNode;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

 * @author rx

 * @date 2022/6/1 17:18

 */

public class StreamDemo13 {

    public static void main(String[] args) {

        List<Student> students = new ArrayList<>();

        students.add(new Student("wang2", 5, "f"));

        students.add(new Student("zh3", 3, "f"));

        students.add(new Student("yx", 88, "f"));

        //计算个数，方法一

        Long collect = students.stream().collect(Collectors.counting());

        System.out.println(collect);

        //计算个数，方法二

        long count = students.stream().count();

        System.out.println(count);

        //通过maxBy求最大值,方法一

        Optional<Student> optional1 = students.stream().collect(Collectors.maxBy(Comparator.comparing(student -> student.getAge())));

        if (optional1.isPresent()) {

            System.out.println(optional1);

        }

//通过maxBy求最大值,方法二

        Optional<Student> max = students.stream().max(Comparator.comparing(Student::getAge));

        if (max.isPresent()) {

            System.out.println(max);

        }

//通过summingInt()进行数据汇总

        Integer collect1 = students.stream().collect(Collectors.summingInt(Student::getAge));

        System.out.println(collect1);

        //通过averagingInt()获取平均值

        Double collect3 = students.stream().collect(Collectors.averagingInt(student -> student.getAge()));

        System.out.println(collect3);

        //通过joining方法进行数据拼接

        String collect2 = students.stream().map(Student::getName).collect(Collectors.joining());

        System.out.println(collect2);

        //复杂结果的返回

        IntSummaryStatistics collect4 = students.stream().collect(Collectors.summarizingInt(Student::getAge));

        collect4.getSum();

        collect4.getMax();

        collect4.getCount();

        collect4.getAverage();

        collect4.getMin();

    }

}

8、分组

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

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

public class StreamDemo14 {

    public static void main(String[] args) {

        List<Student> students = new ArrayList<>();

        students.add(new Student("wang2", 5, "m"));

        students.add(new Student("zh3", 3, "f"));

        students.add(new Student("yx", 88, "m"));

        students.add(new Student("sd", 88, "f"));

        students.add(new Student("cd", 88, "m"));

        Map<String, List<Student>> collect = students.stream().collect(Collectors.groupingBy(Student::getGender));

        System.out.println(collect);

       //结果： {f=[Student{name='zh3', age=3, gender='f'}, Student{name='sd', age=88, gender='f'}], m=[Student{name='wang2', age=5, gender='m'}, Student{name='yx', age=88, gender='m'}, Student{name='cd', age=88, gender='m'}]}

    }

}

　　8.1多级分组

public class StreamDemo15 {

    public static void main(String[] args) {

        List<Student> students = new ArrayList<>();

        students.add(new Student("wang2", 5, "m"));

        students.add(new Student("zh3", 3, "f"));

        students.add(new Student("yx", 88, "m"));

        students.add(new Student("sd", 88, "f"));

        students.add(new Student("cd", 88, "m"));

        Map<String, Map<String, List<Student>>> collect = students.stream().collect(Collectors.groupingBy(Student::getGender, Collectors.groupingBy(Student::getGender)));

        System.out.println(collect);

       //结果：{f={f=[Student{name='zh3', age=3, gender='f'}, Student{name='sd', age=88, gender='f'}]}, m={m=[Student{name='wang2', age=5, gender='m'}, Student{name='yx', age=88, gender='m'}, Student{name='cd', age=88, gender='m'}]}}

    }

}

Java8中Stream()流的用法总结的更多相关文章

Java8中Stream 的一些用法
数据结构和数据准备 @Data @AllArgsConstructor @NoArgsConstructor static class StreamItem { Integer id; String ...
谈一谈Java8的函数式编程（二） --Java8中的流
流与集合众所周知,日常开发与操作中涉及到集合的操作相当频繁,而java中对于集合的操作又是相当麻烦.这里你可能就有疑问了,我感觉平常开发的时候操作集合时不麻烦呀?那下面我们从一个例子说起. 计 ...
Java8函数之旅（二） --Java8中的流
流与集合众所周知,日常开发与操作中涉及到集合的操作相当频繁,而java中对于集合的操作又是相当麻烦.这里你可能就有疑问了,我感觉平常开发的时候操作集合时不麻烦呀?那下面我们从一个例子说起. 计 ...
JDK 8 中Stream流中的去重的方法
JDK 8 中Stream流中去重的方法 1.简单的去重,可以使用distinct()方法去重,该方法是通过比较equals和hashcode值去去重, 2.复杂的去重, 例如,在一个JavaBean ...
【JDK8】JDK 8 中Stream流中的去重的方法
JDK 8 中Stream流中去重的方法 1.简单的去重,可以使用distinct()方法去重,该方法是通过比较equals和hashcode值去去重, 2.复杂的去重, 例如,在一个JavaBean ...
Java8的Stream流(一) --- 基础用法
Java8中的Stream Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象. Stream的特性及优点: 无存储. Stream不是一种数据 ...
Java8中的流操作-基本使用&性能测试
为获得更好的阅读体验,请访问原文:传送门一.流(Stream)简介流是 Java8 中 API 的新成员,它允许你以声明式的方式处理数据集合(通过查询语句来表达,而不是临时编写一个实现).这有点儿 ...
JAVA8之 Stream 流（四）
如果说前面几章是函数式编程的方法论,那么 Stream 流就应该是 JAVA8 为我们提供的最佳实践. Stream 流的定义 Stream 是支持串行和并行操作的一系列元素.流操作会被组合到流管道中 ...
java8之Stream流处理
简介 Stream 流处理,首先要澄清的是 java8 中的 Stream 与 I/O 流 InputStream 和 OutputStream 是完全不同的概念. Stream 机制是针对集合迭代器 ...
Java中stream的详细用法
来自于:Java 8 stream的详细用法_旅行者-CSDN博客_java stream 一.概述 Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行 ...

随机推荐

SpringBoot导读
SpringBoot 一.导读 1.开发工具及技术栈 JDK:jdk1.8.0_191 开发工具:IntelliJIDEA 2020.3.2 SpringBoot: 简化Spring的开发需要一定的 ...
Django中logging的设置
1.日志基础知识日志与我们的软件程序密不可分.它记录了程序的运行情况,可以给我们调试程序和故障排查提供非常有用的信息.每一条日志信息记录了一个事件的发生.具体而言,它包括了: 事件发生时间事件发生 ...
vue - axios简单封装
分析: (1)axios处理接口请求.可能需处理请求拦截,响应拦截,不同类型的请求,所以需要一个http.js文件 (2)请求都是基于相关环境的,所以需要一个url.js处理环境 (3)可根据不同模块 ...
虚拟机重置root用户密码
虚拟机root用户重置密码在打开虚拟机在出现下图界面的时候按 e 进入管理界面 e要快速按不然就会直接进入虚拟机然后找到 UTF-8 在后面添加 rd.break 输入完后按 Ctrl+x 跳 ...
I3D论文总结
最近看了李沐讲论文系列朱毅老师讲的I3D论文精读(视频,笔记),这里记录一下. 1.针对的问题 1.之前的视频数据集都太小,导致大多数流行的动作识别基准都很小,且即使不同模型效果有好有坏也难以区分. ...
简单的python线程池实现线程安全demo
from concurrent.futures import ThreadPoolExecutor import threading import time import sys sys.path.a ...
JS学习-async/await
async/await 它保证函数的返回值为 promise. 用更少的.then()块来封装代码,同时它看起来很像同步代码注意:可能会因为大量await的promises相继发生而变慢. asyn ...
macOS完整安装包下载方法
Python脚本下载开源地址:macadmin-scripts 下载installinstallmacos.py到Mac,然后用python运行,如图: # ProductID Vers ...
如何使用Antd的图片上传组件
html结构如下 <a-upload v-model:file-list="fileList" //已经上传的文件列表(受控) name="avatar" ...
简介Hadoop
Hadoop 简介 Hadoop 是什么 Hadoop 是一个提供分布式存储和计算的开源软件框架,它具有无共享.高可用(HA).弹性可扩展的特点,非常适合处理海量数量. Hadoop 是一个开源软件框 ...

Java8中Stream()流的用法总结

Java8中Stream()流的用法总结的更多相关文章

随机推荐

热门专题