【JDK8】学习测试

/**
	 *解题条件：必须只能使用JDK8的特性，不允许使用非JDK8的其他知识点
     * 问题1：找到已生效的保单列表；
     * 问题2：找到只含有一个被保险人的保单列表，把被保险人姓名用“,”连接起来并打印，如“张三,李四,王五”；
     * 问题3：得到一个Map，key为保单号码，value为每张保单的保期天数
     * 问题4：计算保单列表的平均保费是多少
     * 问题5：用并发流实现Policy的存储(PolicyService#save)，并计算总耗时
     * 问题6：用异步的方式实现Policy的存储(PolicyService#save)，并计算总耗时
     * 问题7: 得到一个新的保单列表，需要对被保险为空的保单用“法外狂徒,100岁”这个被保人兜底
     * 问题8：得到一个Map，key为被保险人名称，value为被保险人年龄
     * 问题9：计算今天开始往后数500天的是哪一天 "YYYY-MM-DD"的格式输出
     * 问题10：给PolicyService新增一个父类【接口】，将save方法提到父类接口内
     */
//问题1：找到已生效的保单列表；
    @org.junit.Test
    public void question01() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        //policyList.forEach(System.out::println);
        LocalDateTime now = LocalDateTime.now();
        List<Policy> policies = policyList.stream().filter(policy -> now.isAfter(policy.getEffectiveDate())).collect(toList());
        policies.forEach(System.out::println);
    }

    //问题2：找到只含有一个被保险人的保单列表，把被保险人姓名用“,”连接起来并打印，如“张三,李四,王五”；
    @org.junit.Test
    public void question02() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        //policyList.forEach(System.out::println);
        //获取只含有一个被保险人的保单列表
        Stream<List<Risk>> listStream = policyList.stream()
                .map(policy -> policy.getRiskList()).filter(risks -> risks != null && risks.isEmpty());//stream<List<Risk>>
        Stream<Risk> riskStream = listStream.flatMap(List::stream);
        Stream<String> stringStream = riskStream.map(Risk::getName);
        String collect = stringStream.collect(Collectors.joining(","));
        System.out.println(collect);
    }

    //问题3：得到一个Map，key为保单号码，value为每张保单的保期天数
    @org.junit.Test
    public void question03() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        Map<String, LocalDateTime> collect = policyList
                .stream()
                .collect(Collectors.toMap(Policy::getPolicyNo, Policy::getExpireDate));
        LocalDateTime now = LocalDateTime.now();
        Map<String, String> collect2 = collect.entrySet()
                .stream()
                .collect(toMap(sEntry -> sEntry.getKey(), sEntry -> {
                    String sDay = Duration.between(now, sEntry.getValue()).toDays() + "";
                    return sDay;
                }));
        System.out.println(collect2);
    }

    //问题4：计算保单列表的平均保费是多少
    @org.junit.Test
    public void question04() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        policyList.forEach(policy -> System.out.println(policy.getPremium()));
        Double avg = policyList.stream().collect(Collectors.averagingDouble(Policy::getPremium));
        System.out.println("平均保费为：" + avg);
    }

    //问题5：用并发流实现Policy的存储(PolicyService#save)，并计算总耗时
    @org.junit.Test
    public void question05() {
        LocalDateTime start = LocalDateTime.now();
        List<Policy> policyList = PolicyService.buildPolicyList();
        PolicyService policyService = new PolicyService();
        List<Policy> list = policyList.parallelStream().map(policy ->
                policyService.save(policy)
        ).collect(toList());
        list.stream().forEach(policy -> System.out.println(policy));
        LocalDateTime end = LocalDateTime.now();
        System.out.println("查询总耗时：：：" + Duration.between(start, end).toMillis());
    }

    //问题6：用异步的方式实现Policy的存储(PolicyService#save)，并计算总耗时
    @org.junit.Test
    public void question06() {
        LocalDateTime start = LocalDateTime.now();
        List<Policy> policyList = PolicyService.buildPolicyList();
        // 自定义线程池，
        ExecutorService executor = Executors.newFixedThreadPool(15);
        List<CompletableFuture<Policy>> completablePolicyList = policyList.stream().map(policy -> CompletableFuture.supplyAsync(() -> {
            Policy save = new PolicyService().save(policy);
            return save;
        }, executor)).collect(toList());
        completablePolicyList.stream().forEach(policyCompletableFuture -> System.out.println(policyCompletableFuture.join()));
        LocalDateTime end = LocalDateTime.now();
        System.out.println("查询总耗时：：：" + Duration.between(start, end).toMillis());
    }

    //问题7: 得到一个新的保单列表，需要对被保险为空的保单用“法外狂徒,100岁”这个被保人兜底
    @org.junit.Test
    public void question07() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        ArrayList<Risk> risks = new ArrayList<>();
        risks.add(new Risk("法外狂徒", 100));
        List<Policy> policyList1 = policyList.stream().map(policy -> {
            List<Risk> risks1 = ofNullable(policy.getRiskList()).orElse(risks);
            policy.setRiskList(risks1);
            return policy;
        }).collect(toList());
        policyList1.stream().forEach(System.out::println);
    }

    //问题8：得到一个Map，key为被保险人名称，value为被保险人年龄
    @org.junit.Test
    public void question08() {
        List<Policy> policyList = PolicyService.buildPolicyList();
        //policyList.forEach(System.out::println);
        Stream<Risk> riskStream = policyList.stream()
                .map(Policy::getRiskList)
                .filter(risks -> risks != null)
                .flatMap(List::stream);

        Map<String, Integer> riskMap = riskStream.collect(toMap(Risk::getName, Risk::getAge));
        System.out.println(riskMap);
    }

    //问题9：计算今天开始往后数500天的是哪一天 "YYYY-MM-DD"的格式输出
    @org.junit.Test
    public void question09() {
        LocalDate localDate = LocalDate.now().plusDays(500);
        System.out.println(localDate);
    }


    //问题10：给PolicyService新增一个父类【接口】，将save方法提到父类接口内
   public interface FatherPolicyService {
   	 default Policy save(Policy policy){
    	    try {
    	        Thread.sleep(2000);
    	        return policy;
    	    } catch (InterruptedException e) {
   	         e.printStackTrace();
     	   }
    	    return null;
   	 	}
	}