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 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行 ...

随机推荐

类Class
C# 类(Class) 当你定义一个类时,你定义了一个数据类型的蓝图.这实际上并没有定义任何的数据,但它定义了类的名称意味着什么,也就是说,类的对象由什么组成及在这个对象上可执行什么操作.对象是类的实 ...
tidevice 报UsbmuxReplyCode.BadDevice错误解决办法
备忘换了个新手机照常使用tidevice进行操作发现报错 tidevice.exceptions.MuxReplyError: UsbmuxReplyCode.BadDevice 查了好久,终于解决 ...
一、Java简单概述
一 . Java组成部分 JDK : java development kit (Java开发工具) JDK是提供给Java开发人员使用的,其中包含了java的开发工具,也包括了JRE. 所以安装了 ...
学习lua-01，遍历集合，多入参循环处理，类型判断，数字运算
--function maxnum(tab1) -- local b = 1 -- local a = tab1[b] -- for i, v in ipairs(tab1) do -- if v & ...
springboot java redis 监听超时事件
package ideal4j.pfa.config.redis; import cn.hutool.core.date.DateTime; import com.alibaba.fastjson.J ...
python菜鸟学习： 1.用户登录输入输出
# -*-coding: utf-8 -*-name = 'liyuzhoupan'password = '123'def login_test(): count = 0 while count &l ...
各种相机以及图片-SLAM14CP5
--2020.10.20 开始学习SLAM.想着从SLAM开始然后做三维重建.前面的李群李代数以及旋转四元数有点复杂.都看过了一遍.但不太理解就先放放.希望接下去能够顺利进行.数学基础可能不是很好,公 ...
Qt实现带有映射关系的进度条
1.编写继承自widget的新类,这里我们定义为colorWidget; 2.在colorWidget中添加私有变量QVector<QRect> m_rects,用于存放进度条的不同区间( ...
go理论知识总结
基于const常量理解个中类型的内存分配引入参考官方:Constant expressions may contain only constant operands and are evaluate ...
Hive. 函数 instr 的用法
INSTR(C1,C2,I,J) 在一个字符串中搜索指定的字符,返回发现指定的字符的位置; C1 被搜索的字符串 C2 希望搜索的字符串 I 搜索的开始位置,默认为1 J 出现的位置,默认为1 sel ...

Java8中Stream()流的用法总结

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

随机推荐

热门专题