java8的stream流的使用

package com.fan.yygh.hosp;

import org.junit.jupiter.api.Test;

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

public class StreamTest {
    @Test //流的创建
    public void test01(){
        //1.通过集合Collections集合提供的stream（）或者parallelStream()
        ArrayList<Integer> list = new ArrayList<Integer>( Arrays.asList(1, 2, 3, 4));
        Stream<Integer> stream1 = list.stream();
        //Stream<Integer> parallelStream = list.parallelStream();

        //2.数组获取流的方式,通过Arrays中的静态方法stream()获取数组流
        int[] arr = new int[]{1,2,3,4};
        IntStream stream2 = Arrays.stream(arr);
        stream2.filter((x) -> x>2)
                .forEach(System.out::println);

        //3.通过Stream类中的静态方法of()来获取流
        Stream<String> stream3 = Stream.of("a", "b", "c");
        Stream.of(6,7,8).forEach(System.out::println);
        stream3.forEach(System.out::println);

        //4.由函数生成流---创建无限流：Stream.iterate和Stream.generate：

        // 4.1，iterate：从0开始，一直在原来数的基础上增加2来生产一个流
        /*static <T> Stream<T> iterate​(T seed, UnaryOperator一元运算<T> f)

        static <T> Stream<T> iterate​(T seed, Predicate<? super T> hasNext,
        UnaryOperator<T> next)
        */
        Stream.iterate(0,(x)->x+2)
                .limit(3)
                .forEach(System.out::println);
        //4.2，static <T> Stream<T> generate​(Supplier<? extends T> s)
        // generate​该方法主要用于生成一个无限连续的无序流，
        // 流中的元素由用户定义的supplier函数生成
        Stream.generate( ()-> Math.random() ) //generate的参数是Supplier供给型接口
              .limit(5) //获取前5个元素，用于限制无限流的长度为5，如果没有limit则是一个死循环输出
              .forEach(System.out::println); //遍历输出
    }
    //中间操作filter
    @Test
    public void test02(){
        //筛选（filter
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        list.stream()
                .filter( x -> x >2 ) //过滤条件，当流中数据大于2的时候放入新流中
                .forEach(System.out::println); //遍历输出
        //案例二：
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

        List<String> listName = personList.stream()
                .filter((x) -> x.getSalary() > 8000) //条件过滤工资
                .map(Person::getName) //提取工资大于8000的人的名字
                .collect(Collectors.toList());//转成list
        System.out.println(listName);
    }

    //中间操作map
    @Test
    public void test03(){
        //map的案例一
        ArrayList<Student> list = new ArrayList<>(Arrays.asList(
                new Student("张三",12,"man"),
                new Student("李四",32,"man"),
                new Student("王五",22,"woman"),
                new Student("赵六",45,"woman")
        ));
        list.stream()
                //.map( Student::getName) //这里使用引用
                .map( (stu)->stu.getName() )
                .forEach(System.out::println);
        //案例2：
        List<String> list1 = Arrays.asList("a", "b", "c");
        list1.stream()
                .map((str)-> {return str.toUpperCase();} )
                .forEach(System.out::println);
        //案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。
        System.out.println("案例一：英文字符串数组的元" +
                "素全部改为大写。整数数组每个元素+3。");
        String[] arr = new String[] {"abcd", "bcdd", "defde", "fTr" };
        Arrays.stream(arr)
                .map( (s)->s.toUpperCase()/*映射规则*/)
                .forEach(System.out::println);

        int[] intArr = new int[]{1,2,3,4};
        Arrays.stream(intArr)
                .map((x) -> x+3)
                .forEach(System.out::println);

        //案例三
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        // 不改变原来员工集合的方式
        List<Person> listNew = personList.stream()
                .map((person) -> {
                    Person p = new Person(person.getName(), 0, 0, null, null);
                    p.setSalary(person.getSalary() + 1000);//设置新工资
                    return p; //返回新person
                })
                .collect(Collectors.toList());//转成集合list
        System.out.println("一次改动前：" + personList);
        System.out.println("一次改动后：" + listNew);

        // 改变原来员工集合的方式
        List<Person> list2 = personList.stream()
                .map((person) -> {
                    person.setSalary(person.getSalary() + 1000);
                    return person;
                })
                .collect(Collectors.toList());
        System.out.println(list2);
        /*========end==========*/
    }
    @Test
    public void test04(){
        //自然排序：流中元素需实现Comparable接口
        List<String> stringList = Arrays.asList("ccc", "aaa", "bbb", "ddd");
        stringList.stream()
                .sorted()
                .forEach(System.out::println);
        //输出： aaa,bbb,ccc,ddd
        //定制排序
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        personList.stream()
                .sorted( (e1,e2)->{
                    //自己实现比较规则
                    if( e1.getSalary() == e2.getSalary()){//如果工资相等
                        return e1.getAge()-e2.getAge();//则按照年龄排序
                    }else{//如果工资不相等，按照工资排序
                        return -(e1.getSalary()-e2.getSalary() );
                    }
                })
                .forEach(System.out::println);
    }
    @Test
    public void test05(){
        String[] arr1 = { "a", "b", "c", "d","c" };
        String[] arr2 = { "d", "e", "f", "g" };

        //1.合并连接：Stream.concat(stream1,stream2)
        System.out.println("合并：");
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);
        Stream.concat(stream1,stream2)
                .forEach(System.out::print); //abcddefg

        //2 .去重,去除重复元素
        System.out.println("\n去重：");
        Arrays.stream(arr1)
                .distinct()
                .forEach(System.out::print);
        // 3.limit：限制从流中获得前n个数据
        System.out.println();
        Stream.iterate(0,x->x+2)
                .limit(5) //获取前5个数据
                .forEach(System.out::println);
        // 4.skip：跳过前n个数据
        Stream.generate(Math::random)
                .limit(10)//获取前10个数
                .skip(5) //并跳过前5个数
                .forEach(System.out::println);
    }
    @Test //终止操作
    public void test06(){
        //1.遍历foreach
        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8);
        list.stream()
                .forEach(System.out::println); //遍历输出
        //2.匹配（find/match）
        //findFirst:  匹配第一个
        Optional<Integer> first = list.stream()
                .findFirst(); //不能再使用其他终止操作forEach
        System.out.println("匹配第一个："+first.get());

        //findAny:匹配任意（适用于并行流）
        Optional<Integer> any = list.parallelStream()
                .findAny();
        System.out.println("找到任意一个："+any.get());
        //match案例3个：
        //allMatch:检查是否匹配所有元素
        boolean b1 = list.stream()
                .allMatch(x -> x > 2);
        System.out.println("检查是否所有元素大于2:"+b1);
        //anyMatch:检查是否至少匹配一个元素
        boolean b2 = list.stream()
                .anyMatch(x -> x > 2);
        System.out.println("检查是否至少有一个元素大于2:"+b2);

        //noneMatch:检查是否没有 匹配所有元素
        boolean b3 = list.stream()
                .noneMatch(x -> x > 2);
        System.out.println("检查是否没有 大于2的元素:"+b3);
    }
    @Test
    public void reducetest(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        // 求和方式1
        Optional<Integer> reduce = list.stream()
                .reduce((x, y) -> x + y);
        System.out.println("求和方式1:"+reduce.get());
        // 求和方式2
        Optional<Integer> reduce1 = list.stream()
                .reduce(Integer::sum);//调用包装类Integer的静态方法sum()
        System.out.println("求和方式2,Integer的静态方法sum:"+reduce1.get());
        // 求和方式3
        Integer reduce2 = list.stream()
                .reduce(0, Integer::sum);//参数一是用来保存归并参数的初始值，参数二是计算方法
        System.out.println("求和方式3:"+reduce2);

        // 求乘积
        Optional<Integer> reduce3 =
                list.stream().reduce((a, b) -> a * b);//参数是2个

        // 求最大值方式1
        Optional<Integer> reduce4 =
                list.stream().reduce((x, y) -> x > y ? x : y);
        // 求最大值写法2
        Optional<Integer> reduce5 = list.stream().reduce(Integer::max);
        Optional<Integer> reduce6 = list.stream().reduce(Integer::min);
        System.out.println("最大值："+reduce5.get());
        System.out.println("最小值："+reduce6.get());

        //求所有员工的工资之和和最高工资。
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        // 求工资之和方式1：
        Optional<Integer> reduce7 = personList.stream()
                .map(Person::getSalary) //映射出所有的工资
                .reduce(Integer::sum);
        System.out.println("求工资之和方式1："+reduce7.get());
        // 求工资之和方式2：
        Integer sumSalary2 = personList.stream()
                .reduce(0, (sum, p) -> sum += p.getSalary(),
                (sum1, sum2) -> sum1 + sum2);
        // 求工资之和方式3：
        Integer sumSalary3 = personList.stream()
                .reduce(0, (sum, p) -> sum += p.getSalary(),
                        Integer::sum);

        // 求最高工资方式3：推荐
        Integer maxSalary3 = personList.stream()
                .map(Person::getSalary).reduce(Integer::max).get();
        // 求最高工资方式1：
        Integer maxSalary = personList.stream()
                .reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
                Integer::max);
        // 求最高工资方式2：
        Integer maxSalary2 = personList.stream()
                .reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
                (max1, max2) -> max1 > max2 ? max1 : max2);
    }
    @Test
    public void testjuhe(){
        List<String> list =
                Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
        Optional<String> max = list.stream().max(Comparator.comparing(String::length));
        System.out.println(max.get());

        //案例三：获取员工薪资最高的人。
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900, 23, "male", "New York"));
        personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
        personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 24, "female", "New York"));
        personList.add(new Person("Owen", 9500, 25, "male", "New York"));
        personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
        Optional<Person> max1 = personList.stream()
                .max(Comparator.comparingInt(Person::getSalary));
        System.out.println("最大工资的人："+max1.get());
    }
}