Stream流的这些操做，你得知道，对你工做有很大帮助

时间  2020-12-08
标签 java 数组 ide this spa code 对象 blog 排序 栏目 Apache 繁體版
原文   原文链接

Stream流

Stream（流）是一个来自数据源的元素队列并支持聚合操做：java

  • 元素是特定类型的对象，造成一个队列。 Java中的Stream并不会存储元素，而 是按需计算。
  • 数据源 流的来源。 能够是集合，数组等。
  • 聚合操做相似SQL语句同样的操做， 好比filter, map, reduce, find, match, sorted 等。

Stream流操做的三个步骤：

  1. 建立Stream

    一个数据源(如：集合、数组)，获取一个流数组

  2. 中间操做

    一个中间操做链，对数据源的数据进行处理ide

  3. 终止操做

    一个终止操做，执行中间操做链，并产生结果ui

建立Stream步骤：

  • 经过Collection系列集合提供的顺序流stream()或并行流parallelStream()
  • 经过Arrays中的静态方法stream()获取数据流
  • 经过Stream类中的静态方法of()

代码实例：this

package com.ysh.review01_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest01 {
    public static void main(String[] args) {
        //第一种方式：经过集合中的stream()方法建立Stream
        List<String> list= Arrays.asList("红太狼","灰太狼","喜羊羊");
        Stream<String> stream=list.stream();
        //经过集合中的parallelStream方法建立
        Stream<String> stream2 = list.parallelStream();
        //第二种方式：经过java.util.Arrays下的静态方法stream建立Stream
        Integer[] integer=new Integer[]{1,2,4};
        //这里须要注意的是Arrays中的stream方法里面的参数须要一个数组，且数组的类型是一个引用类型或者是一个包装类
        Stream<Integer> stream3 = Arrays.stream(integer);
        //第三种方式：经过Stream中的of方法,实际上这种方式建立Stream实际上间接的经过调用Arrays中的stream()静态方法
        Stream<String> stream4=Stream.of("a","b","c");
    }
}

Stream的中间操做

筛选和切片

filter：过滤器spa

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StramTest02 {
    public static void main(String[] args) {
        Employee employee01=new Employee("yang","hui",29);
        Employee employee02=new Employee("yang","hui",49);
        Employee employee03=new Employee("yang","hui",9);
        Employee employee04=new Employee("yang","hui",89);
        Employee employee05=new Employee("yang","hui",89);
        Employee employee06=new Employee("yang","hui",89);
        List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
        //建立Stream
        Stream<Employee> stream1 = list.stream();
        //对stream1流进行过滤
        Stream<Employee> s = stream1.filter((e) -> {
            System.out.println("---------------filter------------");
            //过滤掉年龄小于19
            return e.getAge() >= 19;
        });
        s.forEach((e-> System.out.println(e)));
    }
}
class Employee {
    private String id;
    private String name;
    private int age;

    public Employee() {

    }

    public Employee(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                id.equals(employee.id) &&
                name.equals(employee.name);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

运行结果：code

skip(n):指跳过Stream中存储的前n条数据(包含第n条数据)，返回后n条数据，若是n大于Stream中全部元素的个数，则返回空；(Employee类如上)对象

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StramTest02 {
    public static void main(String[] args) {
        Employee employee01=new Employee("yang","hui",9);
        Employee employee02=new Employee("yang","hui",49);
        Employee employee03=new Employee("yang","hui",9);
        Employee employee04=new Employee("yang","hui",89);
        Employee employee05=new Employee("yang","hui",89);
        Employee employee06=new Employee("yang","hui",89);
        List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
        //建立Stream
        Stream<Employee> stream1 = list.stream();
        //对stream1流进行过滤
        Stream<Employee> s = stream1.filter((e) -> {
            System.out.println("---------------filter------------");
            //过滤掉年龄小于19
            return e.getAge() >= 19;
        }).skip(2);
        //s=s.skip(5);
        s.forEach((e-> System.out.println(e)));
    }
}

运行截图：blog

distinct:筛选重复的元素，经过流生产元素的hashCode()和equals去除重复元素；排序

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;

public class StramTest02 {
    public static void main(String[] args) {
        Employee employee01=new Employee("yang","hui",9);
        Employee employee02=new Employee("yang","hui",49);
        Employee employee03=new Employee("yang","hui",9);
        Employee employee04=new Employee("yang","hui",89);
        Employee employee05=new Employee("yang","hui",89);
        Employee employee06=new Employee("yang","hui",89);
        List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
        //建立Stream
        Stream<Employee> stream1 = list.stream();
        //对stream1流进行过滤
        Stream<Employee> s = stream1.filter((e) -> {
            System.out.println("---------------filter------------");
            //过滤掉年龄小于19
            return e.getAge() >= 19;
        }).skip(2).distinct();
        //s=s.skip(5);
        s.forEach((e-> System.out.println(e)));
    }
}

运行截图：

排序：

sorted(Comparable)–天然排序

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest03 {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("c","bbb","abc","bbbb");
        Stream<String> stream = list.stream();
        //即经过调用String方法中CompareTo，经过一个一个的比较字符的ASCLL值，首先比较首字符的ASCLL大小，相同的话再比较下一个
        stream= stream.sorted();
        stream.forEach(System.out::println);
    }
}

sorted(Comparator)–定制排序

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;

public class StramTest02 {
    public static void main(String[] args) {
        Employee employee01=new Employee("yang","哈哈",19);
        Employee employee02=new Employee("yang","hui",49);
        Employee employee03=new Employee("yang","hui",79);
        Employee employee04=new Employee("yang","呵呵呵",79);
        Employee employee05=new Employee("yang","hui",39);
        Employee employee06=new Employee("yang","hui",29);
        List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
        //建立Stream
        Stream<Employee> stream1 = list.stream();
        //对stream1流进行过滤
        Stream<Employee> s = stream1.filter((e) -> {
            System.out.println("---------------filter------------");
            //过滤掉年龄小于19
            return e.getAge() >= 19;
        });
        //s=s.skip(5);
        /*此处可使用Lambda表达式，即s.sorted((o1,o2)->{
                              //升序排序，若是年龄相同，则按照姓名的长度排序 
                                         if (o1.getAge()==o2.getAge()){
                                            return o1.getName().length()-o2.getName().length();
                                     }
                                      //按照年龄升序排序
                                      return o1.getAge()-o2.getAge();

                          })

         */
        s=s.sorted(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                //升序排序，若是年龄相同，则按照姓名的长度排序
                if (o1.getAge()==o2.getAge()){
                    return o1.getName().length()-o2.getName().length();
                }
                //按照年龄升序排序
                return o1.getAge()-o2.getAge();
            }
        });
        s.forEach((e-> System.out.println(e)));
    }
}

Stream中的map和flatMap方法：

  • 流中的每个数据，当作map方法的参数(接口)，接口中抽象方法的参数，进行制定操做，最终获得一个结果，最后全部的结果返回去成为一个流
  • 流中的每个数据看成参数，进行操做，获得的结果必须是一个流，最终会结合成一个流返回
package com.ysh.review01_Stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest04 {
    public static void main(String[] args) {
        Stream<String> stream=Stream.of("aaa","bbbb","ccccc");
        //map方法是每个数据看成一个流，即以上{aaa}、{bbbb}、{ccccc}各是一个Stream<Character>流集合，即达到获得多个Stream<Character>流集合
        //能够理解为Stream流中包含Stream<Character>流
        //由于这里的testCharacter()的方法我返回的是一个Stream<Character>
        //Stream<Stream<Character>> streamStream = stream.map((e) -> testCharacter(e));
        Stream<Stream<Character>> streamStream = stream.map((e) -> {
            List<Character> list = new ArrayList<>();
            for (Character c : e.toCharArray()) {
                list.add(c);
            }
            return list.stream();
        });
        streamStream.forEach((e)->{
            e.forEach((e2)->{
                System.out.println(e2);
            });
        });
        Stream<String> stm=Stream.of("aaa","bbbb","ccccc");
        //flatMap()方法便是把将获得的多个Stream<Character>流集合合并为一个一个Stream<Character>流集合
        Stream<Character> stream1=stm.flatMap(StreamTest04::testCharacter);
        //streamStream.forEach(System.out::println);
        System.out.println("---------------");
        stream1.forEach(System.out::println);
    }
    //返回一个Stream
    public static Stream<Character> testCharacter(String str){
        List<Character> list=new ArrayList<>();
        for (Character c:str.toCharArray()){
            list.add(c);
        }
        Stream<Character> stream=list.stream();
        return stream;
    }
}

终止操做

查找与匹配

  • allMatch:检查是否匹配全部元素；
  • anyMatch:检查是否至少匹配一个元素；
  • noneMatch:检查是否没有匹配全部元素；
  •  findFirst:返回第一个元素；
  •  findAny:返回当前流中的任意元素；
  •  count:返回流中元素的总个数；
  •  max:返回流中最大值；
  •  min:返回流中最小值；

代码实例：

package com.ysh.review01_Stream;

import java.util.Optional;
import java.util.stream.Stream;

/**
 * Stream中的终止操做
 */
public class StreamTest06 {
    public static void main(String[] args) {
        //获取Stream
        Stream<String> stm1=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //allMatch()方法里面的参数是一个断言式接口，即实现必须重写test()方法
        boolean b1 = stm1.allMatch((t) -> {
            //检查是否匹配全部元素
            return t.length() > 2;
        });
        Stream<String> stm2=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        boolean b2=stm2.anyMatch((t) -> {
            //检查是否至少匹配一个元素
            return t.length() > 2;
        });
        Stream<String> stm3=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        boolean b3=stm3.noneMatch((t) -> {
            //检查是否没有匹配全部元素
            return t.length() > 2;
        });
        Stream<String> stm4=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //获得流中的第一个元素
        Optional<String> first = stm4.findFirst();
        //输出
        System.out.println(first.get());
        Stream<String> stm5=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //返回当前流中的任意元素
        Optional<String> any = stm5.findAny();
        System.out.println(any.get());
        Stream<String> stm6=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //放回流中元素的总个数
        long count = stm6.count();
        System.out.println(count);
        Stream<String> stm7=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //返回流中最大值，即长度最长，长度相同则比较ASCLL值大小
        Optional<String> max = stm7.max((s1, s2) -> {
            if (s1.length()==s2.length()){
                return s1.compareTo(s2);
            }
            return s1.length() - s2.length();
        });
        System.out.println(max.get());
        Stream<String> stm8=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");
        //返回流中最小值，即长度最短，长度相同则比较ASCLL值大小
        Optional<String> min = stm8.min((s1, s2) -> {
            if (s1.length() == s2.length()) {
                return s2.compareTo(s1);
            }
            return s1.length() - s2.length();
        });
        System.out.println(min.get());
        System.out.println(b3);
    }
}

收集：

收集-将流转换为其余形式，接收一个Collertor接口的实现，用于给Stream中元素作 汇总的方法

  •  List：把流中全部元素收集到List中，使用.collect(Collectors.toList());
  •  Set：把流中全部元素收集到Set中，删除重复项，使用.collect(Collectors.toSet());
  •  Map：把流中全部元素收集到Map中，当出现相同的key时会抛异常，使用 .collect(Collectors.toMap());
  •  使用collect方法求流中共有几条数据，使用.collect(Collectors.counting())
  •  使用collect方法求平均数，使用.collect(Collectors.averagingInt();
  • 使用collect方法求某个变量的总和，使用.collect(Collectors.summingDouble());
  • 使用collect方法且某个变量中值的最大值，使用.collect(Collectors.maxBy());

代码实例：

package com.ysh.review01_Stream.one;

import java.util.*;
import java.util.stream.Collectors;

public class StreamTest07 {
    public static void main(String[] args) {
        Student stu1=new Student("1","hhhh",18);
        Student stu2=new Student("2","hhhhh",19);
        Student stu3=new Student("3","oooooo",19);
        Student stu4=new Student("4","aaaaa",19);
        List<Student> list = Arrays.asList(stu1,stu2,stu3,stu4);
        //获取全部学生的姓名流，而且存储再List集合中
        List<String> collect = list.stream().map((e) -> {
            return e.getName();
        }).collect(Collectors.toList());
        System.out.println(collect);
        Set<String> set = list.stream().map((e) -> {
            return e.getName();
        }).collect(Collectors.toSet());
        System.out.println(collect);
        //将学生的姓名和年龄放入到一个集合中，当出现相同的key是会抛出一个java.lang.IllegalStateException: Duplicate key异常
        Map<String, Integer> map = list.stream().collect(Collectors.toMap((e) -> e.getName(), (e2) -> e2.getAge()));
        System.out.println(map);
        //运用collect输出全部学生的总数
        Long count2 = list.stream().collect(Collectors.counting());
        System.out.println(count2);
        //运用collect方法计算全部学生的平均年龄
        Double collect1 = list.stream().collect(Collectors.averagingDouble((n) -> n.getAge()));
        System.out.println(collect1);
        //运用collect方法求全部学生的年龄之和
        int agesum=list.stream().collect(Collectors.summingInt((e)->e.getAge()));
        System.out.println(agesum);
        //运用collect方法求全部学生中年龄最大的
        Optional<Student> max2 = list.stream().collect(Collectors.maxBy((a1, a2) -> a1.getAge() - a2.getAge()));
        System.out.println(max2.get());

    }
}
class Student {
    private String id;
    private String name;
    private int age;
    public Student(){

    }

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                id.equals(student.id) &&
                name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

最后

感谢你看到这里，文章有什么不足还请指正，以为文章对你有帮助的话记得给我点个赞！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程