JAVA中的Stream

01.什么是Stream

Stream是JDK8中引入，Stream是一个来自数据源的元素序列并支持聚合操作。可以让你以一种声明的方式处理数据，Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

02.Stream特点

• 元素：是特定类型的对象，形成一个序列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源：流的来源可以是集合，数组，I/O channel等。
• 过滤、聚合、排序等操作：类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等
• Pipelining（流水线/管道）: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式。
• 只能遍历一次：数据流的从一头获取数据源，在流水线上依次对元素进行操作，当元素通过流水线，便无法再对其进行操作

一个stream是由三部分组成的。数据源，零个或一个或多个中间操作，一个或零个终止操作。

中间操作是对数据的加工，注意：中间操作是lazy操作，并不会立马启动，需要等待终止操作才会执行。

终止操作是stream的启动操作，只有加上终止操作，stream才会真正的开始执行。

03.Stream入门案例

//要求把list1中的空字符串过滤掉，并把结果保存在列表中

public class Test {

    public static void main(String[] args) {

        List<String> list1 = Arrays.asList("ab", "", "cd", "ef", "mm","", "hh");

        System.out.println(list1);//[ab, , cd, ef, mm, , hh]

        List<String> result = list1.stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());

        System.out.println(result);//[ab, cd, ef, mm, hh]

    }

}

上面这个例子可以看出list1是一个字符串的列表，其中有两个空字符串，在stream的操作过程中，我们使用了stream()、filter()、collect()等方法，在filter()过程中，我们引入了Lambda表达式s->!s.isEmpty()，结果是把两个空字符串过滤掉后，形成了一个新的列表result。

上面这个需求如果我们使用传统的代码完成如下：

public class Test {

    public static void main(String[] args) {

        List<String> list1 = Arrays.asList("ab", "", "cd", "ef", "mm","", "hh");

        List<String> result = new ArrayList<>();

        for (String str : list1) {

            if(str.isEmpty()){

                continue;

            }

            result.add(str);

        }

        System.out.println(result);

    }

}

比较两段代码，我们可以发现在第二段代码中我们自己创建了一个字符串对象列表，开启一个for循环遍历字符串对象列表，在for循环中判断是否当前的字符串是空串，如果不是，加到结果列表中。而在第一段程序中，我们并不需要自己开启for循环遍历，stream会在内部做迭代，我们只需要传入我们的过滤条件就可以了，最后这个字符串列表也是代码自动创建出来的，并且把结果放入了列表中，可以看出，第一段代码简洁优雅。

04.Stream操作分类

• 无状态：指元素的处理不受之前元素的影响；
• 有状态：指该操作只有拿到所有元素之后才能继续下去。
• 非短路操作：指必须处理所有元素才能得到最终结果；
• 短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果。

05.Stream使用案例

5.1.创建流

5.1.1.使用Collection下的 stream() 和 parallelStream() 方法

public class Test {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        Stream<String> stream = list.stream(); //获取一个串行流

        Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

    }

}

5.1.2.使用Arrays 中的 stream() 方法，将数组转成流

public class Test {

    public static void main(String[] args) {

        Integer[] nums = new Integer[10];

        Stream<Integer> stream = Arrays.stream(nums);

    }

}

5.1.3.使用Stream中的静态方法：of()、iterate()、generate()

public class Test {

    public static void main(String[] args) {

        Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

        stream.forEach(System.out::print);//1 2 3 4 5 6

        System.out.println("==========");

        Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);

        stream2.forEach(System.out::print); // 0 2 4 6 8 10

        System.out.println("==========");

        Stream<Double> stream3 = Stream.generate(Math::random).limit(2);

        stream3.forEach(System.out::print);//随机产生两个小数

    }

}

5.1.4.使用 BufferedReader.lines() 方法，将每行内容转成流

public class Test {

    public static void main(String[] args) throws FileNotFoundException {

        BufferedReader reader = new BufferedReader(new FileReader("d:\\study\\demo\\test_stream.txt"));

        Stream<String> lineStream = reader.lines();

        lineStream.forEach(System.out::println);

    }

}

5.1.5.使用 Pattern.splitAsStream() 方法，将字符串分隔成流

public class Test {

    public static void main(String[] args) {

        Pattern pattern = Pattern.compile(",");

        Stream<String> stringStream = pattern.splitAsStream("tom,jack,jerry,john");

        stringStream.forEach(System.out::println);

    }

}

5.2.中间操作

5.2.1.筛选与切片

• filter：过滤流中的某些元素
• limit(n)：获取n个元素
• skip(n)：跳过n元素，配合limit(n)可实现分页
• distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素

//filter 测试

public class Test {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("aaa", "ff", "dddd","eeeee","hhhhhhh");

        //把字符串长度大于3的过滤掉

        Stream<String> stringStream = list.stream().filter(s -> s.length() <= 3);

        stringStream.forEach(System.out::println);

        System.out.println("===================");

        //验证整个流只遍历一次

        //stream只有遇到终止操作才会触发流启动，中间操作都是lazy

        Stream.of(1, 2, 3, 4, 5)

        .filter(i -> {

            System.out.println("filter1的元素：" + i);

            return i > 0;

        }).filter(i -> {

            System.out.println("filter2的元素：" + i);

            return i == 5;

        }).forEach(i-> System.out.println("最后结果："+i));

    }

}

//limit 测试

public class Test {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("aaa", "ff", "dddd","eeeee","hhhhhhh");

        //取三个元素

        List<String> result = list.stream().limit(3).collect(Collectors.toList());

        System.out.println(result);

    }

}

//limit 和 skip 测试

public class Test {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("11", "22", "33","44","55","66","77","88","99");

        //演示skip:跳过前三条记录

        list.stream().skip(3).forEach(System.out::println);

        //模拟翻页,每页3条记录

        //第一页

        List<String> page1= list.stream().skip(0).limit(3).collect(Collectors.toList());

        System.out.println(page1);

        //第二页

        List<String> page2= list.stream().skip(3).limit(3).collect(Collectors.toList());

        System.out.println(page2);

        //第三页

        List<String> page3= list.stream().skip(6).limit(3).collect(Collectors.toList());

        System.out.println(page3);

        //limit和skip顺序换一下

        //可以看出，最终的结果会收到执行顺序的影响

        List<String> page4= list.stream().limit(3).skip(1).collect(Collectors.toList());

        System.out.println(page4);

    }

}

//distinct去重测试

//注意：当我们自己重写hashcode和equals的方法的时候，要遵循一个原则：

//如果两个对象的hashcode相等，那么用equals比较不一定相等；反之，如果两个对象用equals比较相等，那么他们的hashcode也一定相等

public class Student {

    private Integer id;

    private String name;

    public Student(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        return getId().equals(student.getId()) &&

                getName().equals(student.getName());

    }

    @Override

    public int hashCode() {

        return Objects.hash(getId(), getName());

    }

    @Override

    public String toString() {

        return "Student{" +

                "id=" + id +

                ", name='" + name + '\'' +

                '}';

    }

}

//去掉重复的student

//1.Student类的hashcode和equals包含了id和name

//2.Student类的hashcode和equals中只包含name

public class Test {

    public static void main(String[] args) {

        List<Student> studentList = Arrays.asList(

               new Student(1, "zhangsan"),

                new Student(6, "zhangsan"),

                new Student(2, "lisi"),

                new Student(5, "lisi"),

                new Student(3, "wangwu"));

        //1.学生对象去重

        List<Student> result = studentList.stream().distinct().collect(Collectors.toList());

        System.out.println(result);

        //2.普通字符串去重

        Stream<String> stringStream = Stream.of("a", "a", "b", "c", "d");

        List<String> stringList = stringStream.distinct().collect(Collectors.toList());

        System.out.println(stringList);

    }

}

5.2.2.映射（map和flatMap）

public class Test {

    public static void main(String[] args) {

            //第一个例子对比

            List<String> list = Arrays.asList("a,b,c", "1,2,3");

            //将每个元素转成一个新的且不带逗号的元素

            //注意：这里元素是值在list中的元素，一共有两个，分别是"a,b,c" 和"1,2,3"

            //map函数传入的lambda表达式就是我们的转换逻辑，需要返回一个转换之后的元素

            Stream<String> s1 = list.stream().map(s -> s.replaceAll(",", ""));

            s1.forEach(System.out::println); // abc  123

            System.out.println("===============");

            List<Integer> integerList = Arrays.asList(1, 2, 3);

            integerList.stream().map(i->i*2).forEach(System.out::println);

            System.out.println("===============");

            //将每个元素转换成一个stream

            //注意：flatMap跟上面的map函数对比

            //两者传入的lambda都是转换逻辑，但是map中的lambda返回的是一个转换后的新元素，

            //flatMap可以把每一个元素进一步处理：例如"a,b,c"进一步分隔成a b c三个元素

            //返回的是这三个元素形成的三个stream，最终把这些单独的stream合并成一个stream返回

            //总结：可以看出，flatMap相比于map，它可以把每一个元素再进一步拆分成更多的元素，

            // 最后，拆分出来的元素个数会多于最初输入的列表中的元素个数

            //就这个例子而言，最初输入两个元素"a,b,c" 和"1,2,3"，结果是6个元素  a b c 1 2 3

            Stream<String> s3 = list.stream().flatMap(s -> {

                String[] split = s.split(",");

                Stream<String> s2 = Arrays.stream(split);

                return s2;

            });

            s3.forEach(System.out::println); // a b c 1 2 3

            System.out.println("===============");

            //第二个例子(嵌套的list)[["a","b","c"],["d","e","f"],["h","k"]]

            //输出结果要求是：["A","B","C","D","E","F","G","H"]

            List<List<String>> nestedList = Arrays.asList(

                                                Arrays.asList("a","b","c"),

                                                Arrays.asList("d","e","f"),

                                                Arrays.asList("h","k")

                                            );

            Stream<String> s4 = nestedList.stream()

                .flatMap(Collection::stream)

                .map(s -> s.toUpperCase());

            s4.forEach(System.out::print);

    }

}

5.2.3.排序

• sorted()：自然排序，流中元素需实现Comparable接口
• sorted(Comparator com)：定制排序，自定义Comparator排序器

//字符串排序

public class Test {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("aaa", "ff", "dddd");

        //String 类自身已实现Compareable接口,可以按照字符的自然顺序【升序】排序

        list.stream().sorted().forEach(System.out::println);// aaa dddd ff

 		System.out.println("=====");

        //给sorted函数传入一个lambda表达式

        //1.自定义排序规则,按照字符串的长度【升序】排序,也就是字符串长度最短的排在最前面

        list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);//ff aaa dddd

 		System.out.println("=====");

        //2.自定义排序规则,按照字符串的长度【降序】排序,也就是字符串长度最长的排在最前面

        list.stream().sorted((s1,s2)->s2.length()-s1.length()).forEach(System.out::println);//dddd aaa ff

    }

}

//对象排序

public class Employee {

    private String name;

    private Integer salary;

    public Employee(String name,Integer salary) {

        this.name = name;

        this.salary = salary;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Integer getSalary() {

        return salary;

    }

    public void setSalary(Integer salary) {

        this.salary = salary;

    }

    @Override

    public String toString() {

        return "Employee{" +

                "name='" + name + '\'' +

                ", salary=" + salary +

                '}';

    }

}

//测试类

public class Test {

    public static void main(String[] args) {

            List<Employee> list = Arrays.asList(

                    new Employee("Tom",1000),

                    new Employee("Jack",900),

                    new Employee("John",1300),

                    new Employee("Jack",2000)

            );

            //自定义排序规则，先按照名称【升序】，如果名称相同，再按照工资【降序】

            list.stream().sorted((e1,e2)->{

                if(e1.getName().equals(e2.getName())){

                    return e2.getSalary()-e1.getSalary();

                }else{

                    return e1.getName().compareTo(e2.getName());

                }

            }).forEach(System.out::println);

            //输出结果：

            //        Employee{name='Jack', salary=2000}

            //        Employee{name='Jack', salary=900}

            //        Employee{name='John', salary=1300}

            //        Employee{name='Tom', salary=1000}

            //打印原始列表，看看是否被改变,注意我们通过stream进行排序操作,原始的列表元素顺序没有变化，也就是说我们没有修改原始的list

            System.out.println(list);

            //Stream排序和集合本身的排序方法对比

            //我们使用List接口本身的sort方法再来排序一下看看

            list.sort((e1,e2)->{

                if(e1.getName().equals(e2.getName())){

                    return e2.getSalary()-e1.getSalary();

                }else{

                    return e1.getName().compareTo(e2.getName());

                }

            });

            //排序后再次打印一下list本身,可以发现，list本身元素的顺序被修改过了

            System.out.println(list);

        }

}

5.2.4.消费

peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。

//为Tom增加500工资

public class Test {

    public static void main(String[] args) {

        List<Employee> list = Arrays.asList(

                new Employee("Tom",1000),

                new Employee("John",1300),

                new Employee("Jack",2000)

        );

        //如果是Tom，工资增加500

        list.stream().peek(e->{

            if("Tom".equals(e.getName())){

                e.setSalary(500+e.getSalary());

            }

        }).forEach(System.out::println);

        //输出结果

//        Employee{name='Tom', salary=1500}

//        Employee{name='John', salary=1300}

//        Employee{name='Jack', salary=2000}

    }

}

5.3.终止操作

5.3.1.匹配

public class Test {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(2, 1, 3, 4, 5);

        //流中所有的元素都匹配，返回true，否则返回false

        boolean allMatch = list.stream().allMatch(e -> {

            System.out.println(e);

            return e > 10;

        }); //false

        System.out.println("allMatch:"+allMatch);

        //流中没有任何的元素匹配，返回true，否则返回false

        boolean noneMatch = list.stream().noneMatch(e -> {

            System.out.println(e);

            return e > 10;

        }); //true

        System.out.println("noneMatch:"+noneMatch);

        //流中只要有任何一个元素匹配，返回true，否则返回false

        boolean anyMatch = list.stream().anyMatch(e -> {

            System.out.println(e);

            return e > 1;

        });  //true

        System.out.println("anyMatch:"+anyMatch);

        //返回流的第一个元素

        Integer findFirst = list.stream().findFirst().get(); //2

        System.out.println("findFirst"+findFirst);

        //返回流中的任意元素

        Integer findAny = list.stream().findAny().get(); //2

        System.out.println("findAny:"+findAny);

    }

}

5.3.2.聚合

public class Test {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        //计算元素总的数量

        long count = list.stream().count(); //5

        System.out.println(count);

        //找出最大的元素（需要传入Lambda比较器）

        Integer max = list.stream().max(Integer::compareTo).get(); //5

        System.out.println(max);

        //找出最小元素（需要传入Lambda比较器）

        Integer min = list.stream().min(Integer::compareTo).get(); //1

        System.out.println(min);

    }

}

5.3.3.归约

在java.util.stream.Stream接口中，reduce有下面三个重载的方法

/**

第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。

*/

Optional<T> reduce(BinaryOperator<T> accumulator);

/**

流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。

*/

T reduce(T identity, BinaryOperator<T> accumulator);

/**

在串行流(stream)中，该方法跟第二个方法一样，即第三个参数combiner不会起作用。

在并行流(parallelStream)中,我们知道流被fork join创建出多个线程进行执行，此时每个线程的执行流程就跟第二个方法reduce(identity,accumulator)一样，而第三个参数combiner函数，则是将每个线程的执行结果当成一个新的流，然后使用第一个方法reduce(accumulator)流程进行归约。

*/

<U> U reduce(U identity,

             BiFunction<U, ? super T, U> accumulator,

             BinaryOperator<U> combiner);

归约应用举例

public class Test {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        Integer v = list.stream().reduce((a1, a2) -> a1 + a2).get();

        System.out.println("reduce计算v="+v);   // 55

        Integer v1 = list.stream().reduce(10, (a1, a2) -> a1 + a2);

        System.out.println("reduce计算v1="+v1);  //65

        Integer v2 = list.stream().reduce(0,

                (a1, a2) -> {

                    return a1 + a2;

                },

                (a1, a2) -> {

                    return 1000; //第二个表达式在串行流中无效，这里返回1000测试

                });

        System.out.println("reduce计算v2="+v2); 

        //并行流reduce传三个参数

        Integer v3 = list.parallelStream().reduce(0,

                (a1, a2) -> {

                    System.out.println(Thread.currentThread().getName()+":parallelStream accumulator: a1:" + a1 + "  a2:" + a2);

                    return a1 + a2;

                },

                (a1, a2) -> {

                    System.out.println(Thread.currentThread().getName()+":parallelStream combiner: a1:" + a1 + "  a2:" + a2);

                    return a1 + a2;

                });

        System.out.println("并行流reduce计算v3=："+v3);

    }

}

5.3.4.收集

collect：接收一个Collector实例，将流中元素收集成另外一个数据结构

<R, A> R collect(Collector<? super T, A, R> collector);

应用举例：

//创建一个Person类

public class Person {

    private String name;

    private String sex;

    private Integer age;

    public Person(String name, String sex, Integer age) {

        this.name = name;

        this.sex = sex;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Person{" +

                "name='" + name + '\'' +

                ", sex='" + sex + '\'' +

                ", age=" + age +

                '}';

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

}

public class Test {

    public static void main(String[] args) {

        //1.collect(Collectors.toList()) 把流转换成一个列表（允许重复值）

        Stream<String> stringStream = Stream.of("aa","bb","dd","ee","bb");

        List<String> listResult = stringStream.collect(Collectors.toList());

        System.out.println(listResult);//[aa, bb, dd, ee, bb]

        //2.collect(Collectors.toSet()) 把流转换成一个集合（去重）

        Stream<String> stringStream1 = Stream.of("aa","bb","dd","ee","bb");

        Set<String> setResult = stringStream1.collect(Collectors.toSet());

        System.out.println(setResult);//[aa, bb, dd, ee]

        //3.collect(Collectors.toCollection(LinkedList::new)) 把流转换成一个指定的集合类型(LinkedList)

        Stream<String> stringStream2 = Stream.of("aa","bb","dd","ee","bb");

        LinkedList<String> linkedListResult = stringStream2.collect(Collectors.toCollection(LinkedList::new));

        System.out.println(linkedListResult);//[aa, bb, dd, ee, bb]

        //4.collect(Collectors.toCollection(ArrayList::new)) 把流转换成一个指定的集合类型(ArrayList)

        Stream<String> stringStream3 = Stream.of("aa","bb","dd","ee","bb");

        ArrayList<String> arrayListResult = stringStream3.collect(Collectors.toCollection(ArrayList::new));

        System.out.println(arrayListResult);//[aa, bb, dd, ee, bb]

        //5.collect(Collectors.toCollection(TreeSet::new)) 把流转换成一个指定的集合类型(TreeSet)

        Stream<String> stringStream4 = Stream.of("aa","bb","dd","ee","bb");

        TreeSet<String> treeSetResult = stringStream4.collect(Collectors.toCollection(TreeSet::new));

        System.out.println(treeSetResult);//[aa, bb, dd, ee]

        //6.collect(Collectors.joining()) 使用joining拼接流中的元素

        Stream<String> stringStream5 = Stream.of("A","B","C","D","E");

        String result5 = stringStream5.collect(Collectors.joining());

        System.out.println(result5);//ABCDE

        //7.collect(Collectors.joining("-")) 使用joining拼接流中的元素并指定分隔符

        Stream<String> stringStream6 = Stream.of("A","B","C","D","E");

        String result6 = stringStream6.collect(Collectors.joining("-"));

        System.out.println(result6);//A-B-C-D-E

        //7.collect(Collectors.joining("-","<",">")) 使用joining拼接流中的元素并指定分隔符

        Stream<String> stringStream7 = Stream.of("A","B","C","D","E");

        String result7 = stringStream7.collect(Collectors.joining("-","<",">"));

        System.out.println(result7);//<A-B-C-D-E>

        //8.collect(Collectors.groupingBy(Person::getSex) 对person流按照性别进行分组

        Stream<Person> stringStream8 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("wangwu", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("xiaoming", "女", 13)

        );

        Map<String, List<Person>> resultMap1 = stringStream8.collect(Collectors.groupingBy(Person::getSex));

        System.out.println(resultMap1.toString());//{女=[Person{name='lisi', sex='女', age=11}, Person{name='xiaoming', sex='女', age=13}], 男=[Person{name='zhangsan', sex='男', age=10}, Person{name='wangwu', sex='男', age=15}, Person{name='zhaoliu', sex='男', age=12}]}

        //9.collect(Collectors.groupingBy(Person::getSex, Collectors.mapping(Person::getName, Collectors.toList())))

        // 对person流按照性别进行分组，并且把每一组对象流中人员的姓名转成列表

        Stream<Person> stringStream9 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("wangwu", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("xiaoming", "女", 13)

        );

        Map<String, List<String>> listMap = stringStream9.collect(

                Collectors.groupingBy(Person::getSex, Collectors.mapping(Person::getName, Collectors.toList()))

        );

        System.out.println(listMap.toString());//{女=[lisi, xiaoming], 男=[zhangsan, wangwu, zhaoliu]}

        //10.collect(Collectors.groupingBy(Person::getSex, Collectors.mapping(Person::getAge, Collectors.maxBy(Integer::compareTo))))

        // 对person流按照性别进行分组，并统计每一组中年龄最大的人的年龄

        Stream<Person> stringStream10 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("wangwu", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("xiaoming", "女", 13)

        );

        Map<String, Optional<Integer>> listMap1 = stringStream10.collect(

                Collectors.groupingBy(Person::getSex, Collectors.mapping(Person::getAge, Collectors.maxBy(Integer::compareTo)))

        );

        System.out.println(listMap1.toString());//{女=Optional[13], 男=Optional[15]}

        //11.collect(

        //           Collectors.groupingBy(Person::getName,

        //                                 Collectors.reducing(BinaryOperator.maxBy(Comparator.comparingInt(Person::getAge)))

        //   )

        //对person流按照性别进行分组，并统计每一组中年龄最大的人

        //这个案例使用了groupingBy和reducing组合

        Stream<Person> stringStream111 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("zhangsan", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("lisi", "女", 13)

        );

        Map<String, Optional<Person>> resultMap111 = stringStream111.collect(

                Collectors.groupingBy(Person::getSex,

                        Collectors.reducing(BinaryOperator.maxBy(Comparator.comparingInt(Person::getAge)))

                )

        );

        System.out.println(resultMap111.toString());//{女=Optional[Person{name='lisi', sex='女', age=13}], 男=Optional[Person{name='zhangsan', sex='男', age=15}]}

        //12.collect(Collectors.groupingBy(Person::getSex,

        //                 Collectors.reducing(0,Person::getAge,(x,y)->x+y)

        //          )

        //        )

        //对person流按照性别进行分组，并统计每一组人员年龄和

        Stream<Person> stringStream121 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("zhangsan", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("lisi", "女", 13)

        );

        Map<String, Integer> resultMap121 = stringStream121.collect(

                Collectors.groupingBy(Person::getSex,

                        Collectors.reducing(0,Person::getAge,(x,y)->x+y)

                )

        );

        /*上面这段如果不使用reducing，还可以用下面这中方式完成

        Map<String, Integer> resultMap121 = stringStream121.collect(

                             Collectors.groupingBy(Person::getSex, Collectors.summingInt(Person::getAge))

        );*/

        System.out.println(resultMap121.toString());//{女=24, 男=37}

        //12.collect(Collectors.groupingBy(Person::getName,  TreeMap::new, Collectors.toList()))

        // 对person流按照name进行分组，结果转成TreeMap，key是name，value是这个组的对象列表

        //groupingBy的第一个参数就是获取分组的属性，第二个参数指定返回类型，第三个是把每个分组里面的对象元素转成一个列表

        Stream<Person> stringStream11 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("lisi", "女", 11),

                new Person("zhangsan", "男", 15),

                new Person("lisi", "男", 12),

                new Person("xiaoming", "女", 13)

        );

        TreeMap<String, List<Person>> listMap2 = stringStream11.collect(

                Collectors.groupingBy(Person::getName,  TreeMap::new, Collectors.toList())

        );

        System.out.println(listMap2.toString());//{lisi=[Person{name='lisi', sex='女', age=11}, Person{name='lisi', sex='男', age=12}], xiaoming=[Person{name='xiaoming', sex='女', age=13}], zhangsan=[Person{name='zhangsan', sex='男', age=10}, Person{name='zhangsan', sex='男', age=15}]}

        //13.collect(Collectors.collectingAndThen(

        //                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))),

        //                ArrayList::new))

        //对Person流先通过TreeSet去重，去重的比较属性是name，然后在把这个TreeSet中的元素转换成ArrayList

        Stream<Person> stringStream12 = Stream.of(

                new Person("lisi", "女", 11),

                new Person("lisi", "女", 11),

                new Person("zhangsan", "男", 15),

                new Person("zhangsan", "男", 15),

                new Person("xiaoming", "女", 13)

        );

        List<Person> list = stringStream12.collect(Collectors.collectingAndThen(

                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))),

                ArrayList::new));//这里的ArrayList::new等同于pset->new ArrayList(pset),是把前面生成的TreeSet赋值给ArrayList构造函数

        System.out.println(list);//[Person{name='lisi', sex='女', age=11}, Person{name='xiaoming', sex='女', age=13}, Person{name='zhangsan', sex='男', age=15}]

        //14.collect(Collectors.groupingBy(Person::getName, Collectors.summingInt(Person::getAge)))

        // 对person流按照姓名进行分组，并对每一个组内的人员的年龄求和

        Stream<Person> stringStream13 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("zhangsan", "女", 11),

                new Person("lisi", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("lisi", "女", 13)

        );

        Map<String, Integer> resultMap2 = stringStream13.collect(Collectors.groupingBy(Person::getName, Collectors.summingInt(Person::getAge)));

        System.out.println(resultMap2.toString());//{lisi=28, zhaoliu=12, zhangsan=21}

        //15.collect(Collectors.groupingBy(Person::getName, Collectors.averagingInt(Person::getAge)))

        // 对person流按照姓名进行分组，并对每一个组内的人员的年龄求平均值

        Stream<Person> stringStream14 = Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("zhangsan", "女", 11),

                new Person("lisi", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("lisi", "女", 13)

        );

        Map<String, Double> resultMap3 = stringStream14.collect(Collectors.groupingBy(Person::getName, Collectors.averagingInt(Person::getAge)));

        System.out.println(resultMap3.toString());//{lisi=14.0, zhaoliu=12.0, zhangsan=10.5}

        //16.parallel().collect(

        //                Collectors.groupingByConcurrent(Person::getSex, Collectors.summingInt(Person::getAge))

        //        )

        //使用并行流，把人员按照性别分组，计算每一组中的年龄和，返回的类型是ConcurrentMap，保证线程安全

        Stream<Person> stringStream16 =  Stream.of(

                new Person("zhangsan", "男", 10),

                new Person("zhangsan", "女", 11),

                new Person("lisi", "男", 15),

                new Person("zhaoliu", "男", 12),

                new Person("zhaoliu", "男", 16),

                new Person("zhaoliu", "男", 17),

                new Person("lisi", "女", 13));

        ConcurrentMap<String, Integer> resultMap4 = stringStream16.parallel().collect(

                Collectors.groupingByConcurrent(Person::getSex, Collectors.summingInt(Person::getAge))

        );

        System.out.println(resultMap4.toString());//{女=24, 男=70}

        //17.collect(Collectors.partitioningBy(p -> p.getAge() > 12))

        //把流中元素根据年龄是否大于12分成两组，保存在Map中，key是true或者false，value是对象列表

        Stream<Person> stringStream17 =  Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("wangwu", "男", 10),

                new Person("lisi", "男", 15),

                new Person("zhaoliu", "女", 13));

        Map<Boolean, List<Person>> resultMap5 = stringStream17.collect(Collectors.partitioningBy(p -> p.getAge() > 12));

        System.out.println(resultMap5.toString());//{false=[Person{name='zhangsan', sex='女', age=11}], true=[Person{name='lisi', sex='男', age=15}, Person{name='lisi', sex='女', age=13}]}

        //18.collect(Collectors.partitioningBy(p -> p.getAge() > 12,Collectors.summingInt(Person::getAge)))

        //把流中元素根据年龄是否大于12分成两组，保存在Map中，key是true或者false，每一组的年龄的和

        Stream<Person> stringStream18 =  Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("wangwu", "男", 10),

                new Person("lisi", "男", 15),

                new Person("zhaoliu", "女", 13));

        Map<Boolean, Integer> resultMap6 = stringStream18.collect(Collectors.partitioningBy(p -> p.getAge() > 12,Collectors.summingInt(Person::getAge)));

        System.out.println(resultMap6.toString());//{false=21, true=28}

        //19.Collectors.toMap：有两个参数的toMap方法，流中对象的key是不允许存在相同的，否则报错

        //toMap的第二个参数需要创建一个列表，并且key对应的元素对象放入列表

        Stream<Person> stringStream19 =  Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("zhaoliu", "女", 13));

        Map<String, List<Person>> resultMap7 = stringStream19.collect(Collectors.toMap(Person::getName, p -> {

            List<Person> personList = new ArrayList<>();

            personList.add(p);

            return personList;

        }));

        System.out.println(resultMap7.toString());//{zhaoliu=[Person{name='zhaoliu', sex='女', age=13}], zhangsan=[Person{name='zhangsan', sex='女', age=11}]}

        //20.Collectors.toMap：有两个参数的toMap方法，流中对象的key是不允许存在相同的，否则报错

        //toMap的第二个参数直接使用流中的对象作为key所对应的value

        Stream<Person> stringStream20 = Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("zhaoliu", "女", 13));

        Map<String, Person> resultMap8 = stringStream20.collect(Collectors.toMap(Person::getName, p -> p));

        System.out.println(resultMap8.toString());//{zhaoliu=Person{name='zhaoliu', sex='女', age=13}, zhangsan=Person{name='zhangsan', sex='女', age=11}}

        //21.Collectors.toMap：有三个参数的toMap方法，流中对象的key是允许存在相同的，

        // 第三个参数表示key重复的处理方式(这里是把重复的key对应的value用新的替换老的)

        //toMap的第二个参数直接使用流中的对象作为key所对应的value

        Stream<Person> stringStream21 = Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("zhangsan", "男", 12),

                new Person("zhaoliu", "男", 13)

        );

        Map<String, Person> resultMap9 = stringStream21.collect(

                Collectors.toMap(Person::getName,

                        p -> p,

                        (oldPerson,newPerson)->newPerson

                )

        );

        System.out.println(resultMap9.toString());//{zhaoliu=[Person{name='zhaoliu', sex='男', age=13}], zhangsan=[Person{name='zhangsan', sex='女', age=11}, Person{name='zhangsan', sex='女', age=11}]}

        //22.Collectors.toMap：有三个参数的toMap方法，流中对象的key是允许存在相同的，第三个参数表示key重复的处理方式(这里是把重复的key对应的value放入列表)

        //toMap的第二个参数直接使用流中的对象作为key所对应的value

        Stream<Person> stringStream22 = Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("zhangsan", "女", 11),

                new Person("zhaoliu", "男", 13)

        );

        Map<String, List<Person>> resultMap10 = stringStream22.collect(

                Collectors.toMap(Person::getName,

                        p -> {

                            List<Person> personList = new ArrayList<>();

                            personList.add(p);

                            return personList;

                        },

                        (oldList,newList)->{

                            oldList.addAll(newList);

                            return oldList;

                        })

        );

        System.out.println(resultMap10.toString());//{zhaoliu=[Person{name='zhaoliu', sex='男', age=13}], zhangsan=[Person{name='zhangsan', sex='女', age=11}, Person{name='zhangsan', sex='女', age=11}]}

        //23.Collectors.toMap：有四个参数的toMap方法，流中对象的key是允许存在相同的，

        //toMap的第二个参数直接使用流中的对象作为key所对应的value

        //第三个参数表示key重复的处理方式(这里是把重复的key对应的value放入列表)

        //第四个参数可以指定一个返回的Map具体类型

        Stream<Person> stringStream23 = Stream.of(

                new Person("zhangsan", "女", 11),

                new Person("zhangsan", "女", 11),

                new Person("zhaoliu", "男", 13)

        );

        Map<String, List<Person>> resultMap11 = stringStream23.collect(

                Collectors.toMap(Person::getName,

                        p -> {

                            List<Person> personList = new ArrayList<>();

                            personList.add(p);

                            return personList;

                        },

                        (oldList,newList)->{

                            oldList.addAll(newList);

                            return oldList;

                        },

                        LinkedHashMap::new

                )

        );

        System.out.println(resultMap11.toString());//{zhangsan=[Person{name='zhangsan', sex='女', age=11}, Person{name='zhangsan', sex='女', age=11}], zhaoliu=[Person{name='zhaoliu', sex='男', age=13}]}

        //24.Collectors.summarizingInt((a -> a.getAge()))

        //针对Integer类型的元素进行汇总计算

        //得到1、元素数量 2、元素的和 3、元素的最大值 4、元素的最小值 5、平均值

        Stream<Person> personStream24=Stream.of(

                        new Person("zhangsan", "女", 11),

                        new Person("zhangsan", "女", 25),

                        new Person("zhaoliu", "男", 13)

        );

        IntSummaryStatistics intSummaryStatistics = personStream24.collect(Collectors.summarizingInt((a -> a.getAge())));

        System.out.println(intSummaryStatistics);//IntSummaryStatistics{count=3, sum=49, min=11, average=16.333333, max=25}

    }

}

最新文章

1. Oracle SqlDeveloper创建JOB
2. 浅谈JavaScript之原型
3. VS2010+Selenium测试脚本设计
4. MarkDown写blog（测试）
5. 基于centos搭建nginx+uwsgi运行django环境
6. 分布式流式处理框架：storm简介 + Storm术语解释
7. 通往成功的钥匙--Web前端开发技术
8. CUBRID学习笔记 6 修改用户密码
9. [设计模式]<<设计模式之禅>>关于接口隔离原则
10. 关于android 自己实现 back键 home键
11. PDF在线预览
12. win10 uwp 毛玻璃
13. （转）十分钟入门pandas
14. 注销/etc/passwd带来的系统登陆不上
15. Python标准异常总结
16. Storage 002 电商数据库设计
17. python基础3 条件判断 if嵌套
18. 《剑指offer》 调整数组顺序使得奇数在偶数前面
19. input 子系统架构总结【转】
20. centos7 下载安装tomcat9

热门文章

1. 为何数据库连接池不采用IO多路复用？
2. Go语言实践模式 - 函数选项模式(Functional Options Pattern)
3. 数据结构篇(2) ts实现单循环链表
4. echarts基本使用与注意事项
5. 《HelloGitHub》第 73 期
6. 使用fastai训练的一个性别识别模型
7. 二、深入学习c++需要掌握的基础知识
8. 824. Goat Latin - LeetCode
9. Linux下MySQL表名区分大小写
10. Python汉诺塔求解