Stream中间操作

1.filter(),函数中间需要一个断言，过滤出我们想要的信息

2.map(),将一个流映射成想要的一个流，这个流的操作可以帮助我们返回。

3.sorted()操作

4.peek()操作

5.注意已经执行完终止操作的流不能接着执行其他操作

package com.ydlclass.feature;

import org.junit.Before;
import org.junit.Test;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class LambdaTest {
    List<Person> personList = new ArrayList<>();
    List<Integer> simpleList = Arrays.asList(15,22,9,11,33,52,14);
    @Before
    public void initData(){
        personList.add(new Person("张三",3000,23,"男","太原"));
        personList.add(new Person("李四",7000,34,"男","西安"));
        personList.add(new Person("王五",5200,22,"女","西安"));
        personList.add(new Person("小黑",1500,33,"女","上海"));
        personList.add(new Person("狗子",8000,44,"女","北京"));
        personList.add(new Person("铁蛋",6200,36,"女","南京"));
    }


    @Test
    //中间操作之过滤
    public void filterTest(){
        //中间操作可以进行多次，复杂的操作，并且返回值依旧是一个stream，不修改原数据，也不会存储，如果需要存储则需要使用归集操作
        //
        Stream<Person> manofSalary = personList.stream().
                filter(person -> person.getSalary() > 3000).
                filter(person -> person.getSex().equals("男"));
        //中间操作的返回值是一个Stream,参数需要一个predicate对象
        manofSalary.forEach(System.out::println);

        //归集操作，这样写会产生异常，原因在于上面的stream已经结束了流，会抛出异常流已经被终止了
        //List<Person> collect = manofSalary.collect(Collectors.toList());
    }

    @Test
    //中间操作之映射，map
    public void mapTest(){
        //原本式员工的信息，现在只想保留工资的内容这就是中间操作
        List<Integer> collect = personList.stream().map(person -> person.getSalary())
                .collect(Collectors.toList());
        System.out.println(collect);

        //将每个员工的薪资张10000元
        personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 10000);
            return person;
        }).forEach(System.out::println);
    }

    @Test
    public void sortTest(){
        //员工薪资从高到底排序
        Stream<Person> sorted = personList.stream().sorted(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getSalary() - o1.getSalary();
            }
        });

        //上面的内容转化更加优雅的写法
        //Stream<Person> sorted1 = personList.stream().sorted(Comparator.comparingInt(Person::getSalary));

        //Stream<Person> sorted1 = personList.stream().sorted((p1, p2) -> p2.getSalary() - p1.getSalary());
        //sorted1.forEach(System.out::println);
        sorted.forEach(System.out::println);
    }

    @Test
    //Stream由于在中间操作时不存储数据，所以不好做调试，使用peek可以帮助调试，如果直接调试那么会直接进入forEach方法中
    //peek的作用1：在中间输出一些关键信息帮助我们调试，作用2给每个员工加100
    public void peekTest(){
        personList.stream().filter(person -> person.getSalary() >= 8000).map(person -> {
            person.setSalary(person.getSalary());
            return person;
        }).peek(System.out::println).collect(Collectors.toList()).forEach(System.out::println);

        System.out.println("______________________");

        personList.stream().peek(person -> person.setSalary(person.getSalary() + 10000)).forEach(System.out::println);
    }


}