Java8之stream

项目上对于list集合操作使用stream流较多，因此专门抽了个时间整理下

整理思路来源于这边博客，讲解的很清晰[传送门](https://blog.csdn.net/y_k_y/article/details/84633001 "传送门")

这篇博客则侧重于实现方法的展示，主要涉及的中间操作符和终止操作符如下

需要注意的是，stream转换流并不会改动原始对象

（1）中间操作符

filter 过滤操作，把不想要的数据过滤。
sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

（2）终止操作符

collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。
count 统计操作，统计最终的数据个数。
findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。

完整代码如下

public class PorblemSolution {
    
    public static void main(String[] args){
        List<Student> list = new ArrayList<Student>();
        list.add(new Student(18,180,'男',"张三"));
        list.add(new Student(19,170,'女',"李四"));
        list.add(new Student(19,170,'男',"王五"));
        list.add(new Student(20,180,'女',"赵六"));
        list.add(new Student(20,181,'男',"陈七"));
        
        // stream接口中定义为  Stream<T> filter(Predicate<? super T> predicate);
        // filter内部参数需为断言语句
        List<Student> res1 = list.stream().filter(stu->stu.getSex()=='男').collect(Collectors.toList());
        System.out.println(res1.toString());//  [姓名：张三年龄：18身高：180性别：男, 姓名：王五年龄：19身高：170性别：男, 姓名：陈七年龄：20身高：181性别：男]
        
        Predicate<Student> stuFilter = (stu->stu.getSex()=='女');
        List<Student> res2 = list.stream().filter(stuFilter).collect(Collectors.toList());
        System.out.println(res2.toString());// [姓名：李四年龄：19身高：170性别：女, 姓名：赵六年龄：20身高：180性别：女]
        
        
        //  Optional的教程可以看菜鸟教程的这边速通讲解https://www.runoob.com/java/java8-optional-class.html
        Optional<Student> firstA = res1.stream().filter(stu->stu.getHeight()==180).findFirst();
        System.out.println(firstA.get());// 姓名：张三年龄：18身高：180性别：男
        
        Optional<Student> firstAny = res2.stream().filter(stu->stu.getSex()=='女').findAny();
        System.out.println(firstAny.isPresent() ? firstAny.get():"对象为空");// 姓名：李四年龄：19身高：170性别：女
        
        int femaleCount = (int) list.stream().filter(stuFilter).count();
        System.out.println("femaleCount="+femaleCount);// femaleCount=2
        
        // 
        // 多字段排序，需实现comparator接口
        list = list.stream().sorted(
                (stu1, stu2) -> {
                    if (stu1.getAge()==stu2.getAge()) {
                        return stu2.getHeight()-stu1.getHeight();
                    } else {
                        return stu1.getAge()-stu2.getAge();
                    }
                }).collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：张三年龄：18身高：180性别：男, 姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：陈七年龄：20身高：181性别：男, 姓名：赵六年龄：20身高：180性别：女]
        
        // 个性化类通过实现Comparable接口自定义排序规则
        list = list.stream().sorted().collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：张三年龄：18身高：180性别：男, 姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]
        
        // 通过lambda表达式定义排序规则（这里以身高为例）
        list = list.stream().sorted((stu1,stu2)->(stu1.getHeight()-stu2.getHeight())).collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：张三年龄：18身高：180性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]
        
        // 利用function实现比较器，进而实现多字段比较
        Function<Student, Integer> byAge = (Student) -> Student.getAge();
        Function<Student, Integer> byHeight = (Student) -> Student.getHeight();
        Comparator<Student> mySort = Comparator.comparing(byAge).thenComparing(byHeight);
        list = list.stream().sorted(mySort).collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：张三年龄：18身高：180性别：男, 姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]
         
        Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
        System.out.println(ageMap.toString());
        // {18=[姓名：张三年龄：18身高：180性别：男], 19=[姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男], 20=[姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]}
    }
}


class Student implements Comparable<Student>  {    
    int age;
    int height;    
    char sex;
    String name;
    Student(){}
    Student(int age,int height,char sex,String name){
        this.age = age;
        this.height = height;
        this.sex = sex;
        this.name = name;
    }
    
    public String toString() {
        return "姓名："+name+"年龄："+age+"身高："+height+"性别："+sex;

        }
    
    @Override
    public int compareTo(Student stu) {
        if (this.getAge()==stu.getAge()) {
            return this.getHeight()-stu.getHeight();
        } else {
            return this.getAge()-stu.getAge();
        }
    }
    
    public int getAge() {
        return age;
    }

    public int getHeight() {
        return height;
    }

    public char getSex() {
        return sex;
    }

    public String getName() {
        return name;
    }

    
}

 

 

一、filter

stream接口中定义为  Stream<T> filter(Predicate<? super T> predicate);

因此，我们使用filter则需要传入Predicate断言语句，预先编译好的还是lambda表达式都行

（1）利用lambda表达式实现

        List<Student> res1 = list.stream().filter(stu->stu.getSex()=='男').collect(Collectors.toList());
        System.out.println(res1.toString());//  [姓名：张三年龄：18身高：180性别：男, 姓名：王五年龄：19身高：170性别：男, 姓名：陈七年龄：20身高：181性别：男]

注意最后我们利用collect(Collectors.toList())又重新将stream流转换回list

（2）设定好Predicate后作为参数传入

        Predicate<Student> stuFilter = (stu->stu.getSex()=='女');
        List<Student> res2 = list.stream().filter(stuFilter).collect(Collectors.toList());
        System.out.println(res2.toString());// [姓名：李四年龄：19身高：170性别：女, 姓名：赵六年龄：20身高：180性别：女]

（3）利用Optional实现特定的查找功能（Optional可以预防空指针的出现，注意isPresent用法）

        //  Optional的教程可以看菜鸟教程的这边速通讲解https://www.runoob.com/java/java8-optional-class.html
        Optional<Student> firstA = res1.stream().filter(stu->stu.getHeight()==180).findFirst();
        System.out.println(firstA.get());// 姓名：张三年龄：18身高：180性别：男
        
        Optional<Student> firstAny = res2.stream().filter(stu->stu.getSex()=='女').findAny();
        System.out.println(firstAny.isPresent() ? firstAny.get():"对象为空");// 姓名：李四年龄：19身高：170性别：女

（4）计数（注意count()的返回是long类型的，使用时需要注意类型转换）

        int femaleCount = (int) list.stream().filter(stuFilter).count();
        System.out.println("femaleCount="+femaleCount);// femaleCount=2

 

二、sorted

stream接口中定义sorted为 Stream<T> sorted();与 Stream<T> sorted(Comparator<? super T> comparator);

要想使用sorted()则需要实现Comparable，否则会报错，要使用Comparator则需要实现自定义的比较器

（1）使用个性化类重写的排序方法排序

        // 个性化类通过实现Comparable接口自定义排序规则
        list = list.stream().sorted().collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：张三年龄：18身高：180性别：男, 姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]

 

（2）使用lambda自定义排序规则

        // 通过lambda表达式定义排序规则（这里以身高为例）
        list = list.stream().sorted((stu1,stu2)->(stu1.getHeight()-stu2.getHeight())).collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：张三年龄：18身高：180性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]

 

（3）利用Comparator.comparing(function)实现比较器，进而实现多字段比较

        // 利用function实现比较器，进而实现多字段比较
        Function<Student, Integer> byAge = (Student) -> Student.getAge();
        Function<Student, Integer> byHeight = (Student) -> Student.getHeight();
        Comparator<Student> mySort = Comparator.comparing(byAge).thenComparing(byHeight);
        list = list.stream().sorted(mySort).collect(Collectors.toList());
        System.out.println(list.toString());
        // [姓名：张三年龄：18身高：180性别：男, 姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男, 姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]

 

 

三、补充

（1）Collectors还提供了分组方法groupingBy来实现类似sql中的group by效果

        Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
        System.out.println(ageMap.toString());
        // {18=[姓名：张三年龄：18身高：180性别：男], 19=[姓名：李四年龄：19身高：170性别：女, 姓名：王五年龄：19身高：170性别：男], 20=[姓名：赵六年龄：20身高：180性别：女, 姓名：陈七年龄：20身高：181性别：男]}

 

（2）Comparable与Comparator的区别

主要在于使用方法的不同，比如

public class PorblemSolution {
    
    public static void main(String[] args){
        List<Student> list = new ArrayList<Student>();
        list.add(new Student(18,180,'男',"张三"));
        list.add(new Student(19,170,'女',"李四"));
        list.add(new Student(19,170,'男',"王五"));
        list.add(new Student(20,180,'女',"赵六"));
        list.add(new Student(20,181,'男',"陈七"));
        
        // 使用Comparable
        list = list.stream().sorted().collect(Collectors.toList());
        
        // 使用Comparator
        Collections.sort(list,new Student());

    }
}


class Student  implements  Comparable<Student>,Comparator<Student>{    
    int age;
    int height;    
    char sex;
    String name;
    Student(){}
    Student(int age,int height,char sex,String name){
        this.age = age;
        this.height = height;
        this.sex = sex;
        this.name = name;
    }
    
    public String toString() {
        return "姓名："+name+"年龄："+age+"身高："+height+"性别："+sex;

        }
    
    @Override
    public int compareTo(Student stu) {
        if (this.getAge()==stu.getAge()) {
            return this.getHeight()-stu.getHeight();
        } else {
            return this.getAge()-stu.getAge();
        }
    }
    
    @Override
    public int compare(Student stu1, Student stu2) {
        if (stu1.getHeight()==stu2.getHeight()) {
            return stu1.getAge()-stu2.getAge();
        } else {
            return stu1.getHeight()-stu2.getHeight();
        }
    }
    
    public int getAge() {
        return age;
    }

    public int getHeight() {
        return height;
    }

    public char getSex() {
        return sex;
    }

    public String getName() {
        return name;
    }
    
}