forEach java 并行流 java stream 并行流

 

Java 函数式编程 stream流（一）

1.  Stream和parallelStream

　　stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。如果流中的数据量足够大，并行流可以加快处速度。除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

　　使用Stream的静态方法生成流：of()、iterate()、generate()

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

        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 3).limit(4);
        stream3.forEach(System.out::println);

        Stream<Double> stream4 = Stream.generate(Math::random).limit(3);
        stream4.forEach(System.out::println);

 

2. Stream使用

　　map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
　　flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

public static void main(String[] args) {

        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三", 1000, 20, "男", "北京"));
        personList.add(new Person("李四", 2000, 21, "男", "南京"));
        personList.add(new Person("王五", 3000, 20, "女", "合肥"));
        personList.add(new Person("赵六", 4000, 22, "男", "四川"));
        personList.add(new Person("孙七", 5000, 25, "女", "上海"));

        List<Person> personListNew = personList.stream().map(person -> {
            Person personNew = new Person(person.getName(), 0, 0, null, null);
            personNew.setSalary(person.getSalary() + 10000);
            return personNew;
        }).collect(Collectors.toList());
        System.out.println("一次改动前：" + personList.get(0).getName() + ">>>" + personList.get(0).getSalary());
        System.out.println("一次改动后：" + personListNew.get(0).getName() + ">>>" + personListNew.get(0).getSalary());

        List<Person> personListNew2 = personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 10000);
            return person;
        }).collect(Collectors.toList());
        System.out.println("二次改动前：" + personList.get(0).getName() + ">>>" + personList.get(0).getSalary());
        System.out.println("二次改动后：" + personListNew2.get(0).getName() + ">>>" + personListNew2.get(0).getSalary());

    }

　　

 　　结果：方式一：不改变原来员工集合；方式二：改变原来员工集合的方式

 

// 将两个字符数组合并成一个新的字符数组
        List<String> list = Arrays.asList("Hello", "World");
        Stream<String> stringStream = list.stream().map(s -> s.split("")).flatMap(Arrays::stream);
        stringStream.forEach(System.out::print);

        // 给定两个数字列表 获取所有的数对
        List<Integer> numbers1 = Arrays.asList(1, 2, 3);
        List<Integer> numbers2 = Arrays.asList(3, 4);
        List<int[]> collect = numbers1.stream().flatMap(x -> numbers2.stream().map(y -> new int[]{x, y})).collect(Collectors.toList());
        collect.forEach(c-> System.out.println(Arrays.toString(c)));

 

归集（toMap）

List<Person> personList3 = new ArrayList<>();
        personList3.add(new Person("张三", 1000, 20, "男", "北京"));
        personList3.add(new Person("李四", 2000, 21, "男", "南京"));
        personList3.add(new Person("王五", 3000, 20, "女", "合肥"));
        personList3.add(new Person("赵六", 4000, 22, "男", "四川"));
        personList3.add(new Person("孙七", 5000, 25, "女", "上海"));
        Map<String, Integer> map = personList3.stream().filter(person -> person.getSalary() > 3000).collect(Collectors.toMap(Person::getName, Person::getSalary));
        System.out.println("工资大于3000元的员工:" + map);

　　结果：工资大于3000元的员工:{孙七=5000, 赵六=4000}

　　

统计(count/averaging)

　　Collectors提供了一系列用于数据统计的静态方法

　　计数：count
　　平均值：averagingInt、averagingLong、averagingDouble
　　最值：maxBy、minBy
　　求和：summingInt、summingLong、summingDouble
　　统计以上所有：summarizingInt、summarizingLong、summarizingDouble

List<Person> personList4 = new ArrayList<>();
        personList4.add(new Person("张三", 1000, 20, "男", "北京"));
        personList4.add(new Person("李四", 2000, 21, "男", "南京"));
        personList4.add(new Person("王五", 3000, 20, "女", "合肥"));
        personList4.add(new Person("赵六", 4000, 22, "男", "四川"));
        personList4.add(new Person("孙七", 5000, 25, "女", "上海"));

        // 员工总人数
        long count = personList4.stream().count();
        // 平均工资
        Double salary = personList4.stream().collect(Collectors.averagingDouble(Person::getSalary));
        // 最高工资
        Optional<Integer> max = personList4.stream().map(Person::getSalary).max(Integer::compare);
        // 工资之和
        int sum = personList4.stream().mapToInt(Person::getSalary).sum();
        //一次性统计所有信息
        DoubleSummaryStatistics summaryStatistics = personList4.stream().collect(Collectors.summarizingDouble(Person::getSalary));
        System.out.println("员工总人数：" + count);
        System.out.println("员工平均工资：" + salary);
        System.out.println("员工工资总和：" + max);
        System.out.println("员工工资所有统计：" + summaryStatistics);

 

分组(partitioningBy/groupingBy)

　　分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
　　分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

List<Person> personList5 = new ArrayList<>();
        personList5.add(new Person("张三", 1000, 20, "男", "北京"));
        personList5.add(new Person("李四", 2000, 21, "男", "南京"));
        personList5.add(new Person("王五", 3000, 20, "女", "合肥"));
        personList5.add(new Person("赵六", 4000, 22, "男", "合肥"));
        personList5.add(new Person("孙七", 5000, 25, "女", "上海"));

        // 按薪资高于3000分组
        Map<Boolean, List<Person>> salaryGroup = personList5.stream().collect(Collectors.partitioningBy(p -> p.getSalary() > 3000));
        List<Person> group1 = salaryGroup.get(true);
        List<Person> group2 = salaryGroup.get(false);
        for (Person person : group1) {
            System.out.println("薪资高于3000元组：" + person);
        }
        for (Person person : group2) {
            System.out.println("薪资低于3000元组：" + person);
        }

        // 按性别分组
        Map<String, List<Person>> sexGroup = personList5.stream().collect(Collectors.groupingBy(Person::getSex));
        List<Person> group3 = sexGroup.get("男");
        List<Person> group4 = sexGroup.get("女");
        for (Person person : group3) {
            System.out.println("男子组：" + person);
        }
        for (Person person : group4) {
            System.out.println("女子组：" + person);
        }

        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> group = personList5.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        Map<String, List<Person>> manGroup = group.get("男");
        Map<String, List<Person>> womenGroup = group.get("女");
        List<Person> group5 = manGroup.get("合肥");
        List<Person> group6 = womenGroup.get("上海");
        System.out.println("地区在合肥的男子组：" + group5);
        System.out.println("地区在上海的女子组：" + group6);

 

接合(joining)

　　joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

String persons = personList5.stream().map(p -> p.getName() + "-" + p.getSex() + "-" + p.getSalary()).collect(Collectors.joining(","));
        System.out.println("所有员工信息：" + persons);

　　结果：所有员工信息：张三-男-1000,李四-男-2000,王五-女-3000,赵六-男-4000,孙七-女-5000

 

排序(sorted)

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

List<Person> personList6 = new ArrayList<>();
        personList6.add(new Person("张三", 16000, 20, "男", "北京"));
        personList6.add(new Person("李四", 8500, 21, "男", "南京"));
        personList6.add(new Person("王五", 7300, 20, "女", "合肥"));
        personList6.add(new Person("赵六", 8000, 22, "男", "合肥"));
        personList6.add(new Person("孙七", 15860, 25, "女", "上海"));

        // 按工资升序排序（自然排序）
        List<String> newList = personList6.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());

        // 按工资倒序排序
        List<String> newList2 = personList6.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());

        // 先按工资再按年龄升序排序
        List<String> newList3 = personList6.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());

        // 先按工资再按年龄自定义排序（降序）
        List<String> newList4 = personList6.stream().sorted((p1, p2) -> {
            if (p1.getSalary().equals(p2.getSalary())) {
                return p2.getAge() - p1.getAge();
            } else {
                return p2.getSalary() - p1.getSalary();
            }
        }).map(Person::getName).collect(Collectors.toList());
        System.out.println("按工资升序排序：" + newList);
        System.out.println("按工资降序排序：" + newList2);
        System.out.println("先按工资再按年龄升序排序：" + newList3);
        System.out.println("先按工资再按年龄自定义降序排序：" + newList4);

　　

 

提取/组合

　　流也可以进行合并、去重、限制、跳过等操作。

String[] arr1 = {"a", "b", "c", "d"};
        String[] arr2 = {"d", "e", "f", "g"};
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);
        // concat:合并两个流 distinct：去重
        List<String> collect1 = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());

        List<Integer> collect2 = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());

        List<Integer> collect3 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

        System.out.println("流合并：" + collect1);
        System.out.println("limit：" + collect2);
        System.out.println("skip：" + collect3);