java8Stream流的使用1--中间操作

实体类

@Data
public class Employee {
    public Employee(String name, int age, double value, Bm bm) {
        this.name = name;
        this.age = age;
        this.value = value;
        this.bm = bm;
    }

    private String name;
    private int age;
    private double value;
    private Bm bm;

    @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 &&
                Double.compare(employee.value, value) == 0 &&
                Objects.equals(name, employee.name) &&
                bm == employee.bm;
    }

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

    public enum Bm{
        BM1,
        BM2,
        BM3
    }
}

集合元素

List<Employee> employeeList= Arrays.asList(
            new Employee("张龙",52,5656.3, Employee.Bm.BM1),
            new Employee("赵虎",22,9999.3, Employee.Bm.BM2),
            new Employee("王朝",75,77776.3, Employee.Bm.BM3),
            new Employee("马汉",33,7656.3, Employee.Bm.BM1),
            new Employee("马汉",33,7656.3, Employee.Bm.BM1),
            new Employee("zl",42,5656.3, Employee.Bm.BM1),
            new Employee("zh",12,9999.3, Employee.Bm.BM2),
            new Employee("wc",75,77776.3, Employee.Bm.BM3),
            new Employee("mh",63,7656.3, Employee.Bm.BM1)
    );

     /**
     * 过滤
     */
    @Test
    public void streamFilter(){
        employeeList.stream()
                    .filter(item-> item.getAge()>50)
                    .forEach(System.out::println);
    }

    /**
     * 截断
     */
    @Test
    public void streamLimit(){
        employeeList.stream()
                    .filter(item->{
                        System.out.println("过滤"+item.getAge());
                        return item.getAge()>50;
                    })
                    //当数量已经达到截断数量后，过滤函数不会继续执行
                    .limit(2)
                    .forEach(System.out::println);
    }
    /**
     * 跳过
     */
    @Test
    public void streamSkip(){
        employeeList.stream()
                    .filter(item->item.getAge()>0)
                    .skip(2)
                    .forEach(System.out::println);
    }

    /**
     * 去重,hashcode equals方法
     */
    @Test
    public void streamDistinct(){
        employeeList.stream()
                    .filter(item->item.getAge()>0)
                    .distinct()
                    .forEach(System.out::println);
    }

    /**
     * 映射
     */
    @Test
    public void streamMap(){
        employeeList.stream()
                    .filter(item->item.getAge()>0)
                    .map(Employee::getAge)
                    .forEach(System.out::println);
    }
    /**
     * 将映射成的所有新流合并
     */
    @Test
    public void streamFlagMap(){
        Integer a[]={1,2,3};
        employeeList.stream()
                    .filter(item->item.getAge()>0)
                    .flatMap(StreamTest::getChar)
                    .forEach(System.out::println);
    }

    public static Stream getChar(Employee e){
        ArrayList<Character> characters = new ArrayList<Character>();
        for(Character c:e.getName().toCharArray()){
            characters.add(c);
        }
        return characters.stream();
    }

    /**
     * 排序
     */
    @Test
    public void streamSort(){
        employeeList.stream()
                .filter(item->item.getAge()>0)
                //自然排序，根据comparable的compareTo
                //.sorted()
                .sorted((item1,item2)->Integer.compare(item1.getAge(),item2.getAge()))
                .forEach(System.out::println);
    }