Java8Stream流2

上期对stream流大致总结了一下，后面又做了一些练习，大家可以参考一下。

• 首先需要建一个 Product的实体类，后面会用到

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product {
    private Long id;
    private Integer num;
    private BigDecimal price;
    private String name;
    private String category;

}

• 下面是一些具体的案例

Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
    Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
    Product prod3 = new Product(3L, 3, new BigDecimal("30"), "月饼", "零食");
    Product prod4 = new Product(4L, 3, new BigDecimal("10"), "青岛啤酒", "啤酒");
    Product prod5 = new Product(5L, 10, new BigDecimal("15"), "百威啤酒", "啤酒");
    List<Product> proList = Lists.newArrayList(prod1,prod2,prod3,prod4,prod5);
    @Test
    public void testG(){
        Map<String, List<Product>> proMap = proList.stream().collect(Collectors.groupingBy(Product::getCategory));
        for(Map.Entry<String,List<Product>> entry : proMap.entrySet()){
            System.out.println("key" + entry.getKey() + " value" + entry.getValue());
        }
    }

    @Test
    public void testCollect1(){
        //求总数
        Long sum = proList.stream().collect(Collectors.counting());
        //求平均数量
        Double averageNum = proList.stream().collect(Collectors.averagingInt(Product::getNum));
        //求最高价格
        Optional<BigDecimal> max = proList.stream()
                .map(Product::getPrice)
                .collect(Collectors.maxBy(BigDecimal::compareTo));
        //求数量之和
        Long collect = proList.stream().collect(Collectors.summingLong(Product::getNum));
        //一次性统计所有信息
        LongSummaryStatistics proLSS = proList.stream().collect(Collectors.summarizingLong(Product::getNum));

        log.info("求总数:{}", sum);
        log.info("求总求平均数量数:{}" ,averageNum);
        log.info("求最高价格:{}" ,max.get());
        log.info("求数量之和:{}" ,collect);
        //System.out.println("求总数" + sum);
        //System.out.println("求平均数量" + averageNum);
//        System.out.println("求最高价格" + max);
//        System.out.println("求数量之和" + collect);
        System.out.println("一次性统计所有信息" + proLSS);

        //将产品按数量是否大于5分区
        Map<Boolean, List<Product>> partList = proList.stream().collect(Collectors.partitioningBy(n -> n.getNum() > 5));
        log.info("按数量是否大于5分区:{}",partList);
        //将产品按类别分组
        Map<String, List<Product>> groupList = proList.stream().collect(Collectors.groupingBy(p -> p.getCategory()));
        Map<String, List<Product>> groupList1 = proList.stream().collect(Collectors.groupingBy(Product::getCategory));
        log.info("将产品按类别分组:{}",groupList);
        log.info("将产品按类别分组:{}",groupList1);

    }

    @Test
    public void testJoiningReducing(){
        //将所有产品的 名称 拼接成一个字符串
        String names = proList.stream().map(Product::getName).collect(Collectors.joining("_"));
        log.info("所有产品名:{}",names);

        List<String> strList = Arrays.asList("A", "B", "C", "D");
        String strJoining = strList.stream().collect(Collectors.joining("+_+"));
        log.info("字符串:{}",strJoining);

        Integer collect = proList.stream().collect(Collectors.reducing(0, Product::getNum, (x, y) -> (x + y + 1)));
        log.info("collect:{}",collect);

        //stream中的reduce
        Optional<Integer> reduce = proList.stream().map(Product::getNum).reduce(Integer::compare);
        log.info("stream->reduce:{}",reduce.get());
    }

    @Test
    public void testSorted1(){
        //按 数量升序排列
        List<Product> sortedList = proList.stream().sorted(Comparator.comparing(Product::getNum))
                .collect(Collectors.toList());
        log.info("sorted:{}",sortedList);

        //按数量倒叙排
        List<Product> sortedListReversed = proList.stream().sorted(Comparator.comparing(Product::getNum).reversed())
                .collect(Collectors.toList());
        log.info("sored.reversed:{}",sortedListReversed);

        //先按数量排，再按价格排 (默认升序）
        List<Product> collect = proList.stream().sorted(Comparator.comparing(Product::getNum).thenComparing(Product::getPrice))
                .collect(Collectors.toList());
        log.info("先按数量排，再按价格排 :{}",collect);

        //先按数量排，再按价格排 (降序排）
        List<Product> collect1 = proList.stream()
                .sorted(Comparator.comparing(Product::getNum).thenComparing(Product::getPrice).reversed())
                .collect(Collectors.toList());
        log.info("先按数量排，再按价格降序排 :{}",collect1);

        //先按数量排 再按价格 自定义排
        List<Product> collect2 = proList.stream().sorted((p1, p2) -> {
            if (p1.getNum() == p2.getNum()){
                return p1.getPrice().compareTo(p2.getPrice()) ;
            }else {
                return p2.getNum() - p1.getNum();
            }
        }).collect(Collectors.toList());
        log.info("先按数量排 再按价格 自定义排:{}",collect2);
    }

    //测试stream中reduce (规约 也成为缩减 是把一个流缩减成一个值 能实现对集合求和，求积 和求最值的操作)
    @Test
    public void testStreamReduce() {
        //求商品 价格的总和 方式1
        Optional<BigDecimal> sum = proList.stream().map(Product::getPrice)
                .reduce((x, y) -> x.add(y));
        log.info("求和:{}",sum.get());

        //求商品 数量的总和 方式2
        Optional<Integer> sum1 = proList.stream().map(Product::getNum)
                .reduce(Integer::sum);
        log.info("求和:{}",sum1.get());

        //求商品 价格的总和 方式2
        Optional<BigDecimal> sum2 = proList.stream().map(Product::getPrice)
                .reduce(BigDecimal::add);
        log.info("求和sum2:{}",sum2.get());

        //求商品 价格的总和 方式3
        BigDecimal sum3 = proList.stream().map(Product::getPrice)
                .reduce(new BigDecimal("0"),BigDecimal::add);
        log.info("求和sum3:{}",sum3);

        //求乘积
        Optional<Integer> product = proList.stream().map(Product::getNum).reduce((x, y) -> x * y);
        log.info("乘积:{}",product);

        //求最大值 方式 1
        Optional<BigDecimal> maxPrice = proList.stream().map(Product::getPrice)
                .reduce((x, y) -> x.compareTo(y) == 1 ? x : y);
        log.info("商品价格的最大值:{}",maxPrice);

        //求最大值 方式2
        BigDecimal max2 = proList.stream().map(Product::getPrice)
                .reduce(new BigDecimal(1), BigDecimal::max);
        log.info("求 最大值 方式2:{}",max2);
    }