标签：stream employees System 笔记 println 归约 分组 Employee out

Stream实现收集分组归约

package com.atguigu.java8;

import com.sun.media.jfxmediaimpl.HostUtils;
import org.testng.annotations.Test;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

/**
 * @version 1.0
 * @Author 罗宗苇
 * @Date 2021/10/12 8:49
 * @注释
 */

// API：应用程序编程接口
// Optional 中有处理空字符串的功能
/*
* allMatch:检查是否匹配所有的元素，boolean allMatch(Predicate<? super T> predicate);
* anyMatch:检查是否至少匹配一次 boolean anyMatch(Predicate<? super T> predicate);
* noneMatch:检查是否没有匹配所有元素
* */
public class TestStreamAPI3 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 1132, Employee.Status.FREE),
            new Employee("李四", 48, 1232, Employee.Status.BUSY),
            new Employee("王五", 18, 3432, Employee.Status.VOCATION),
            new Employee("赵六", 67, 1432, Employee.Status.FREE),
            new Employee("赵六", 12, 1432, Employee.Status.FREE),
            new Employee("罗湖", 12, 1432, Employee.Status.FREE),
            new Employee("史蒂夫", 50, 2342, Employee.Status.FREE)
    );

    /*
    * 收集
    *   collect——将流转换为其他形式，接受一个Collector接口实现，用于给Stream中元素做汇总方法
    * */

    @Test
    public void test10(){
        String str = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",","===","===z"));
        System.out.println(str);
    }

    @Test
    public void test9(){
        DoubleSummaryStatistics dss = employees.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dss.getAverage());
        System.out.println(dss.getMax());
        System.out.println(dss.getSum());
    }

    //分区
    @Test
    public void test8(){
        Map<Boolean, List<Employee>> map = employees.stream()
                .collect(Collectors.partitioningBy((e) -> e.getSalary() >= 1500));
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()){
            Map.Entry entry = (Map.Entry)it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }

    //多级分组
    @Test
    public void test7(){
        Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                })));
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()){
            Map.Entry entry = (Map.Entry)it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }

    //分组
    @Test
    public void test6(){
        Map<Employee.Status,List<Employee>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()){
            Map.Entry entry = (Map.Entry)it.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }

    @Test
    public void test5(){
        //总数
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println(count);

        //平均值
        Double avg = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        //总和
         Double sum = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);

        //最大值
        Optional<Employee> max = employees.stream()
                .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(max);

        //最小值
        Optional<Double> min = employees.stream()
                .map(Employee::getSalary)
                .collect(Collectors.minBy(Double::compare));
        System.out.println();
    }

    @Test
    public void test4(){
        List<String> list = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        list.forEach(System.out::println);

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

        Set<String> set = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());
        set.forEach(System.out::println);

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

        HashSet<String> hashSet = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        hashSet.forEach(System.out::println);
    }


    //归约 T reduce(T identity, BinaryOperator<T> accumulator)
    //      Optional<T> reduce(BinaryOperator<T> accumulator)
    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,3,5,3);

        //因为该sum有初始值为0，不可能再为空
        Integer sum = list.stream()
                .reduce(0,(x, y) -> x + y);
        System.out.println(sum);

        //该sum是Double中的静态方法，可能为空
        Optional<Double> op = employees.stream()
                .map(Employee::getSalary)
                .reduce(Double::sum);
        System.out.println(op.get());
    }

    @Test
    public void test2(){
        long count = employees.stream()
                .count();
        System.out.println(count);

        //找到工资的最大值
        Optional<Employee> op = employees.stream()
                .max((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(op.get());

        //找到年龄的最小值
        Optional<Employee> op2 = employees.stream()
                .min((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()));
        System.out.println(op2.get());

        //找到工资的最小值，使用Stream API 中引用传递的特性
        Optional<Double> op3 = employees.stream()
                //将Employee中的getSalary提取出来形成一个Double集合
                .map(Employee::getSalary)
                //在Double集合中找出最小值，并返回一个Double类型的值
                .min(Double::compare);
        System.out.println(op3.get());
    }

    @Test
    public void test1(){
        boolean b1 = employees.stream()
                .allMatch((e) -> e.getStatus().equals(Employee.Status.FREE));
        System.out.println(b1);

        boolean b2 = employees.stream()
                .anyMatch((e) -> e.getStatus().equals(Employee.Status.FREE));
        System.out.println(b2);

        boolean b3 = employees.stream()
                                .noneMatch((e) -> e.getStatus().equals(Employee.Status.VOCATION));
        System.out.println(b3);

        //Optional 可是处理空指针异常
        Optional<Employee> op = employees.stream()
                //先进行从小到大排序，返回最小值；从大到小返回最大值
                .sorted((e1, e2) -> Double.compare(e1.getSalary(),e2.getSalary()))
                .findFirst();   //返回第一个值
        System.out.println(op.get());

        System.out.println("--------------------------");
        Optional<Employee> op2 = employees.parallelStream()
                .filter((e) -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(op2.get());
    }
}

标签：stream,employees,System,笔记,println,归约,分组,Employee,out
来源： https://blog.csdn.net/asddsa1233122132/article/details/120811851

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