Stream流处理五分钟快速上手，满足日常需求

Stream流处理是我们学习集合和文件操作必不可少的环节，熟悉stream操作能增强得我们更加方便处理信息能力，重要性不亚于Lambda表达式，废话少说上代码！

import org.junit.jupiter.api.Test;

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

public class demo1 {

    public List<Person> myList(){
        //创建员工表
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("一号",12,"销售部",8000));
        list.add(new Person("二号",23,"后勤部",4500));
        list.add(new Person("三号",42,"人事部",5000));
        list.add(new Person("四号",41,"人事部",12000));
        list.add(new Person("五十号",29,"人事部",16000));

        return list;
    }



    @Test
    public void test01(){
        //获取员工List集合
        List<Person> list = myList();


        //遍历输出
        list.stream().forEach(System.out::println);
        /*
        Person{name='一号', age=12, dept='销售部', salary=8000}
        Person{name='二号', age=23, dept='后勤部', salary=4500}
        Person{name='三号', age=42, dept='人事部', salary=5000}
        Person{name='四号', age=41, dept='人事部', salary=12000}
        Person{name='五十号', age=29, dept='人事部', salary=16000}
       */

        //筛选工资大于9000员工
        List<Person> collect = list.stream().filter(x -> x.getSalary() > 9000).collect(Collectors.toList());
        List<Integer> collect1 = list.stream().filter(x -> x.getSalary() > 9000).map(Person::getSalary).collect(Collectors.toList());
        /*
            [Person{name='四号', age=41, dept='人事部', salary=12000},
            Person{name='五十号', age=29, dept='人事部', salary=16000}]
         */


        //筛选年龄最大、名字字符串长度最长
        Optional<Person> ageMax = list.stream().max(Comparator.comparingInt(Person::getAge));
        Optional<Integer> ageMax1 = list.stream().map(x -> x.getAge()).reduce((x, y) -> x > y ? x : y);
        /*42*/
        Optional<String> nameLengthMax = list.stream().map(Person::getName).max(Comparator.comparing(String::length));
        Optional<String> nameLengthMax1 = list.stream().map(x -> x.getName()).reduce((x, y) -> x.length() > y.length() ? x : y);
        /* 五十号 */

        //匹配第一个
        Optional<Person> first = list.stream().filter(x -> x.getSalary() > 30).findFirst();
        List<Person> first1 = list.stream().filter(x -> x.getSalary() > 30).limit(1).collect(Collectors.toList());
       /* Person{name='一号', age=12, dept='销售部', salary=8000} */
        //匹配任意一个
        Optional<Person> findAny = list.parallelStream().filter(x -> x.getSalary() > 30).findAny();
        /* Person{name='三号', age=42, dept='人事部', salary=5000} */

        //全员工资加1000
        list.stream().map(x -> {
            x.setSalary(x.getSalary() + 1000);
            return x;
        }).forEach(System.out::println);
        /*
            Person{name='一号', age=12, dept='销售部', salary=9000}
            Person{name='二号', age=23, dept='后勤部', salary=5500}
            Person{name='三号', age=42, dept='人事部', salary=6000}
            Person{name='四号', age=41, dept='人事部', salary=13000}
            Person{name='五十号', age=29, dept='人事部', salary=17000}
         */

        //求工资总和
        Integer sum = list.stream().mapToInt(x -> x.getSalary()).sum();
        Integer sum1 = list.stream().collect(Collectors.summingInt(Person::getSalary));
        Integer sum2 = list.stream().map(x -> x.getSalary()).reduce(0,Integer::sum);
        /* 50500 */


        //返回工资小于8000员工，结果为Map集合
        Map<Person,Integer> map = list.stream().filter(p -> p.getSalary() < 8000).collect(Collectors.toMap(p -> p, Person::getSalary ));
        for (Map.Entry<Person,Integer> e: map.entrySet()){
            System.out.println(e.getKey()+":"+e.getValue());
        }
        /*
            Person{name='二号', age=23, dept='后勤部', salary=5500}:5500
            Person{name='三号', age=42, dept='人事部', salary=6000}:6000
        */

        //按照工资排序，输出名单
        //升序
        List<String> sort = list.stream().sorted(Comparator.comparingInt(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
        /* [二号, 三号, 一号, 四号, 五十号] */
        //降序
        List<String> sortReused = list.stream().sorted(Comparator.comparingInt(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
        /* [五十号, 四号, 一号, 三号, 二号] */


        //合并两个流
        List<Integer> l1 = Arrays.asList(1,2,3,4,5);
        List<Integer> l2 = Arrays.asList(4,5,6,7,8);
        List<Integer> concatList = Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
        /* [1, 2, 3, 4, 5, 4, 5, 6, 7, 8] */

        //去除流中重复数据
        List<Integer> distinctList = concatList.stream().distinct().collect(Collectors.toList());
        /* [1, 2, 3, 4, 5, 6, 7, 8] */

        //忽略前3个元素
        List<Integer> skipList = distinctList.stream().skip(3).collect(Collectors.toList());
        /* [4, 5, 6, 7, 8] */
    }



}