Java jdk8新特性Stream API

深碍√TFBOYSˉ_ 2023-07-25 09:13 12阅读 0赞

首先创建一个Person类备用：

package jdk8;
    
    import java.util.ArrayList;
    
    public class Person implements Comparable<Person>{
        
        private String name;
        private int age;
        private double salary;
    
        public Person() {
        
        }
    
        public static ArrayList<Person> getList(){
        
            Person p1 = new Person("张三", 3, 30.0);
            Person p3 = new Person("王五", 5, 50.0);
            Person p2 = new Person("李四", 4, 80.0);
            Person p4 = new Person("赵六", 6, 60.0);
            ArrayList<Person> list = new ArrayList<>();
            list.add(p1);
            list.add(p2);
            list.add(p3);
            list.add(p4);
            return list;
        }
        public Person(String name, int age, double salary) {
        
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
    
        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;
        }
    
        public double getSalary() {
        
            return salary;
        }
    
        public void setSalary(double salary) {
        
            this.salary = salary;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", salary=" + salary +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
    
            Person person = (Person) o;
    
            if (age != person.age)
                return false;
            if (Double.compare(person.salary, salary) != 0)
                return false;
            return name != null ? name.equals(person.name) : person.name == null;
        }
    
        @Override
        public int hashCode() {
        
            int result;
            long temp;
            result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            temp = Double.doubleToLongBits(salary);
            result = 31 * result + (int) (temp ^ (temp >>> 32));
            return result;
        }
    
        @Override
        public int compareTo(Person o) {
        
            return this.getAge()-o.getAge();
        }
    }

## 获取Stream的四种方式 ##

//获取Stream的四种方式
        @Test
        public void getStream(){
        
            //方式一：通过Collection得到
            ArrayList<Person> list = Person.getList();
            //串行流
            Stream<Person> s1 = list.stream();
            //并行流
            Stream<Person> ps1 = list.parallelStream();
    
            //方式二：通过Arrays的stream()方法
            IntStream s2 = Arrays.stream(new int[]{
        1, 2, 3});
    
            //方式三：通过Stream的of()方法
            Stream<String> s3 = Stream.of("a", "b", "c");
    
            //方式四：创建无限流
            //迭代
            Stream<Integer> stream1 = Stream.iterate(0, x -> x * 2);
            //生成
            Stream<Double> stream2 = Stream.generate(() -> Math.random());
        }

## Stream的中间操作 ##

//中间操作：筛选
        @Test
        public void testFilter(){
        
            ArrayList<Person> list = Person.getList();
            Stream<Person> stream = list.stream();
            //forEach()是一个迭代终止操作
            stream.filter(e->e.getAge() > 4).forEach(obj -> System.out.print(obj));
        }
    
        //中间操作：去除重复元素，需要重写hashcode()和equals()方法
        @Test
        public void testDistinct(){
        
            ArrayList<Person> list = Person.getList();
            list.add(new Person("张三", 3, 30.0));
            System.out.println(list);
            Stream<Person> stream = list.stream();
            stream.distinct().forEach(System.out::println);
        }
    
        //中间操作：截取前几个数据
        @Test
        public void testLimit(){
        
            ArrayList<Person> list = Person.getList();
            Stream<Person> stream = list.stream();
            stream.limit(3).forEach(System.out::println);
        }
    
        //中间操作：跳过几个数据
        @Test
        public void testSkip(){
        
            ArrayList<Person> list = Person.getList();
            Stream<Person> stream = list.stream();
            stream.skip(2).forEach(System.out::println);
        }
    
        //中间操作：映射成一个新的流
        @Test
        public void testMap(){
        
            ArrayList<Person> list = Person.getList();
            Stream<Person> stream = list.stream();
            stream.map(e->e.getAge()).forEach(System.out::println);
        }
    
        //中间操作：把流中的每个元素都换成另外一个流
        @Test
        public void testFlatMap(){
        
            ArrayList<Integer[]> list = new ArrayList();
            list.add(new Integer[]{
        1,2});
            list.add(new Integer[]{
        3,4});
            list.stream().forEach(obj-> System.out.println(Arrays.toString(obj)));
            list.stream().map(Arrays::stream).forEach(
                    s->s.forEach(obj-> System.out.print(obj + " "))
            );
            System.out.println();
            list.stream().flatMap(Arrays::stream).forEach(obj-> System.out.print(obj + " "));
        }
    
        //中间操作：排序
        @Test
        public void testSorted(){
        
            ArrayList<Person> list = Person.getList();
            Stream<Person> stream = list.stream();
            //自然排序,需要实现Comparable接口
            stream.sorted().forEach(System.out::println);
    
            //定制排序
            list.stream().sorted((o1,o2)-> (int) (o1.getSalary()-o2.getSalary())).forEach(System.out::println);
        }

## Stream的终止操作 ##

//终止操作：匹配
        @Test
        public void testMatch(){
        
            ArrayList<Person> list = Person.getList();
            //是否全部匹配
            boolean b1 = list.stream().allMatch(e -> e.getAge() > 2);
            System.out.println("b1 = " + b1);
            //检查是否至少匹配一个,例如：是否存在姓张
            boolean b2 = list.stream().map(e -> e.getName()).anyMatch(str -> str.startsWith("张"));
            System.out.println("b2 = " + b2);
            //检查是否没有匹配的元素，例如：是否存在薪水大于100
            boolean b3 = list.stream().map(e -> e.getSalary()).noneMatch(t -> t > 100);
            System.out.println("b3 = " + b3);
        }
    
        //终止操作：查找、计数
        @Test
        public void testFind(){
        
            ArrayList<Person> list = Person.getList();
            //返回第一个元素
            Optional<Person> first = list.stream().findFirst();
            System.out.println("first = " + first);
            //返回任意一个元素
            Optional<Person> any = list.parallelStream().findAny();
            System.out.println("any = " + any);
            //返回最大值，例如：返回最大的年龄
            Optional<Integer> max = list.stream().map(p -> p.getAge()).max(Integer::compare);
            System.out.println("max = " + max);
            //返回最小值，例如：返回薪水最高的员工
            Optional<Person> min = list.stream().min((p1, p2) -> (int) (p1.getSalary() - p2.getSalary()));
            System.out.println("min = " + min);
            //计数，例如：返回年龄大于4的个数
            long count = list.stream().filter(p -> p.getAge() > 4).count();
            System.out.println("count = " + count);
        }
    
        //终止操作：归约 
        @Test
        public void testReduce(){
        
            ArrayList<Person> list = Person.getList();
            //计算薪水总和
            Optional<Double> reduce = list.stream().map(Person::getSalary).reduce((Double::sum));
            System.out.println("reduce = " + reduce);
            //加初始值的归约
            List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
            Integer reduce1 = list1.stream().reduce(10, Integer::sum);
            System.out.println("reduce1 = " + reduce1);
        }
    
        //终止操作：收集
        @Test
        public void testCollect(){
        
            ArrayList<Person> list = Person.getList();
            List<Person> tolist = list.stream().collect(Collectors.toList());
            tolist.forEach(System.out::println);
    
            Double collect = list.stream().map(Person::getAge).collect(Collectors.averagingDouble(a -> (double) a));
            System.out.println("collect = " + collect);
        }