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

随机推荐

【C++复习】第七章类的继承（基类、派生类、虚基类）
1.基类与派生类类的继承:面向对象的程序设计中提供了类的继承机制,允许程序员在保持原有类特性的基础上,进行更具体.更详细的定义用途:代码的重用性(继承)和可扩充性(派生) 例:植物大战僵尸游戏中, ...
VEU开发之element-ui中关闭dialog时并销毁
el-dialog正常使用过程中,经常会发现一些问题,就是dialog加载的组件,每次打开都会有上次的内容,其实是加载到节点未被删除,只是反复隐藏/显示. <el-button type=&qu ...
JS正则表达式大全(整理详细且实用)2
javascript的17种正则表达式 "^\\d+$" //非负整数(正整数 + 0) "^[0-9]*[1-9][0-9]*$" //正整数 "^ ...
plsql--游标用法
1.游标概念在 PL/SQL 块中执行 SELECT.INSERT.DELETE 和 UPDATE 语句时,ORACLE 会在内存中为其分配上下文区(Context Area),即缓冲区.游标是指向 ...
How to use lspci, lsscsi, lsusb, and lsblk to get Linux system devices information
There are many utilities available to check Linux system hardware information. Some commands report ...
js 处理日期加减
js 处理日期加减开始时间设置为6点整,若当前时间小于6:00:00,则使用T-1,否则使用T 结束时间设置为T+1的6点整 Date.prototype.format = function(fmt ...
java jdk8安装之后java -version失败
将此目录下的(C:\Program Files (x86)\Common Files\Oracle\Java\javapath_target_86850671)三个.exe文件删除即可!
31 ModelForm常用功能--扩充
ModelForm自定义字段的显示效果 class ChargeModelForm(BootStrapModelForm, forms.ModelForm): # 静态变量 # charge_type ...
obspy常用命令记录
如何使用obspy(适用于MAC.Linux.Windows)完全替代SAC(使用于Linux和MAC) 波形预处理 # 去均值 stream.detrend('demean') # 去线性趋势 st ...
核函数（kernel function）
在接触反演.算法等方面的知识后,经常听到"核"这个字,它不像对原始变量的线性变换,也不像类似于机器学习中激活函数那样的非线性变换,对原始数据进行变换,就可以将复杂的问题简单化.接下 ...

Java8中Stream()流的用法总结

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

随机推荐

热门专题