标签：Stream list System Employee 归约 println 集合 new out

Stream流的集合元素归约

什么是归约？

归约即将集合的所有元素缩减为一个值，例如求均值、求和等
stream中使用reduce函数实现

字母哥最后一节视频讲的很好，推荐看视频
https://www.bilibili.com/video/BV1sE411P7C1?p=10&vd_source=3c88fb7dae36f53e6a15081fb7cf9ff8

实践

package com.zimuge.stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Test;

/**
 * 功能描述
 *
 * @since 2022-06-13
 */
public class StreamTest {

    @Test
    public void test1() {

        // list 流过滤
        List<String> strings = Arrays.asList("zhangsan", "lisi", "wangwu", "zhouliu");
        List<String> sorted = strings.stream().filter(str -> str.startsWith("z")).map(String::toUpperCase).sorted().collect(Collectors.toList());
        System.out.println(sorted);

        // Array 数组流过滤
        String[] str1 = {"zhangsan", "lisi", "wangwu", "zhouliu"};
        List<String> sorted1 = Stream.of(str1).filter(str -> str.endsWith("u")).map(String::toLowerCase).sorted().collect(Collectors.toList());
        System.out.println(sorted1);

        // Set 流过滤
        HashSet<String> strings1 = new HashSet<>(strings);
        Set<String> z = strings1.stream().filter(str -> str.startsWith("z")).map(String::toUpperCase).sorted().collect(Collectors.toSet());
        System.out.println(z);
    }


    @Test
    public void test2() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);

//        List<Employee> f = list.stream()
//                .filter(e -> e.getAge() > 35 || e.getGender().equals("M"))
//                .collect(Collectors.toList());

        // 两个实现都可以，下面的实现谓词可以复用
        List<Employee> f = list.stream()
                .filter(Employee.ageGreaterThan35.or(Employee.genderM))
                .collect(Collectors.toList());
        System.out.println(f);

    }

    @Test
    public void test3() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);

        List<Employee> m = list.stream()
                .filter(v -> v.getAge() > 25)
                .map(e -> {
                    e.setAge(e.getAge() + 1);
                    e.setGender(e.getGender().equals("M") ? "Male" : "Female");
                    return e;
                })
                .collect(Collectors.toList());
        System.out.println(m);

        // 与上面map+return一样
        List<Employee> m1 = list.stream()
                .filter(v -> v.getAge() > 25)
                .peek(e -> {
                    e.setAge(e.getAge() + 1);
                    e.setGender(e.getGender().equals("M") ? "Male" : "Female");
                })
                .collect(Collectors.toList());
        System.out.println(m1);
    }

    @Test
    public void test4() {
        List<String> list = Arrays.asList("Hello", "World");
        list.stream()
                .map(e -> e.split(""))
                .forEach(System.out::println);

        list.stream()
                .map(e -> Arrays.stream(e.split("")))
                .forEach(System.out::println);

        list.stream()
                .flatMap(e -> Arrays.stream(e.split("")))
                .forEach(System.out::println);

    }

    /**
     * 有状态操作及串并行操作
     */
    @Test
    public void test5() {
        List<String> list = Arrays.asList("Hello", "World", "Aba", "Aba", "haha", "Aba", "dgh", "yeah");
        list.stream()
                .parallel()
                .distinct()
                .limit(5)
                .skip(2)
                .sorted()
                .forEach(System.out::println);
    }

    @Test
    public void test6() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);

        // 都是正序
        list.sort(Comparator.comparing(Employee::getGender).thenComparingInt(Employee::getAge));
        list.forEach(System.out::println);
        // 都是逆序
        list.sort(Comparator.comparing(Employee::getGender).thenComparingInt(Employee::getAge).reversed());
        list.forEach(System.out::println);
        // 一逆一正
        list.sort(Comparator.comparing(Employee::getGender).reversed().thenComparingInt(Employee::getAge));
        list.forEach(System.out::println);
        // 一正一逆
        list.sort(Comparator.comparing(Employee::getGender).reversed().thenComparingInt(Employee::getAge).reversed());
        list.forEach(System.out::println);
    }


    @Test
    public void test7() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);
        list.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        list.forEach(System.out::println);
        System.out.println("list = " + list);
    }

    @Test
    public void test8() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);
        boolean b = list.stream().anyMatch(e -> e.getAge() > 58);
        System.out.println(b);
        boolean b1 = list.stream().allMatch(e -> e.getAge() > 58);
        System.out.println(b1);

        Optional<Employee> first = list.stream().filter(e -> e.getAge() > 40).findFirst();
        System.out.println(first.get());

        // 抛异常
//        Optional<Employee> first1 = list.stream().filter(e -> e.getAge() > 80).findFirst();
//        System.out.println(first1.get());

        Optional<Employee> any = list.stream().filter(e -> e.getAge() > 40).findAny();
        System.out.println(any.get());

        boolean present = list.stream().filter(e -> e.getAge() > 40).findFirst().isPresent();
        System.out.println(present);

        list.stream().filter(e -> e.getAge() > 40).findFirst().ifPresent(System.out::println);
    }

    @Test
    public void test9() {
        Employee e1 = new Employee(1, 21, "zhangsan", "F");
        Employee e2 = new Employee(2, 45, "lisi", "M");
        Employee e3 = new Employee(3, 60, "wangwu", "M");
        Employee e4 = new Employee(4, 32, "zhouliu", "F");
        Employee e5 = new Employee(5, 28, "zhaoqi", "M");
        Employee e6 = new Employee(6, 43, "qianba", "F");

        List<Employee> list = Arrays.asList(e1, e2, e3, e4, e5, e6);
        //求所有员工年龄和最大值
        Optional<Integer> reduce = list.stream().map(Employee::getAge).reduce(Integer::sum);
        System.out.println(reduce.get());

        Optional<Integer> reduce2 = list.stream().map(Employee::getAge).reduce(Integer::max);
        System.out.println(reduce2.get());

        // 并行流实现
        Optional<Integer> reduce3 = list.parallelStream().map(Employee::getAge).reduce(Integer::sum);
        System.out.println(reduce3.get());

        Integer int1 = list.stream().reduce(0, (total, emp) -> total + emp.getAge(), Integer::sum);
        System.out.println(int1);

    }
}

标签：Stream,list,System,Employee,归约,println,集合,new,out
来源： https://www.cnblogs.com/Oh-mydream/p/16391657.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。