java 8各种api的操作_java8的api怎么调-CSDN博客

本文链接：https://blog.csdn.net/qq_43636574/article/details/113677267

该博客主要介绍了如何使用Java的Stream API进行数据分组和分片，以实现1000个一组的多线程异步处理。在处理过程中，涉及到了对查询结果的分组、按纯度排序、价格计算以及库存数据的整合。通过CompletableFuture进行异步编排，确保所有任务执行完毕后，将结果按价格排序并返回。

摘要由CSDN通过智能技术生成

    @Override
    public List<List<KeyCustomerQueryProductPackage>> getAllProductPackage() {
        List<QueryPackages> queryProductPackageList = productMapper.getAllPackages();
        //将查询到的所有的产品包装按csno分组
        List<List<QueryPackages>> collect = queryProductPackageList.stream().collect(Collectors.collectingAndThen(Collectors.groupingBy(QueryPackages::getItemId), map -> new ArrayList<>(map.values())));
        //将分组后的数据在1000个一组分片以便多线程异步处理
        List<List<List<QueryPackages>>> collect2 = Stream.iterate(0, n -> n + 1).limit(collect.size() / 1000 + 1).parallel().map(a -> collect.stream().skip(a * 1000).limit(1000)
                .parallel().collect(Collectors.toList())).collect(Collectors.toList());
        //存储每个分片的处理结果
        List<CompletableFuture<List<List<KeyCustomerQueryProductPackage>>>> futureTask = new ArrayList<>();
        //异步编排处理分片数据
        collect2.forEach(item -> {

            CompletableFuture<List<List<KeyCustomerQueryProductPackage>>> productPackageTask = CompletableFuture.supplyAsync(() -> {
                //单个分片任务处理
                List<List<KeyCustomerQueryProductPackage>> task = item.stream().map(m -> {
                    //获得最大纯度
                    List<ProductBatch> productBatchList = productMapper.getProductBatchByCatalogNo(m.get(0).getItemId());
                    String finalMaxPurity = productBatchList.size() > 0 && productBatchList != null
                            ? productBatchList.stream().map(m1 -> getNumber(m1.getPurity())).sorted(Comparator.reverseOrder()).findFirst().orElse("") : "";
                    //同个csNo组数据进行处理(根据所需数据格式)
                    List<KeyCustomerQueryProductPackage> o = m.stream().map(p -> {

                        KeyCustomerQueryProductPackage key = new KeyCustomerQueryProductPackage();
                        key.setDescription(p.getDescription());
                        key.setItemId(p.getItemId());
                        key.setItemName(p.getItemName());
                        key.setPack(p.getPack());
                        key.setPrice(StringUtils.isNotBlank(p.getPrice()) ? getMoney(Double.valueOf(p.getPrice()) * 0.65) : "0.00");
                        key.setPurity(StringUtils.isNotEmpty(finalMaxPurity) ? (Double.valueOf(getNumber(finalMaxPurity)) >= 98 ? "98%" : Double.valueOf(getNumber(finalMaxPurity)).intValue() + "%") : p.getPurity());
                        Map map = new LinkedHashMap();
                        if (StringUtils.isNotBlank(p.getCity())) {
                            map.put(p.getCity(), p.getCity().equals("上海") ? p.getGross() + "g" : (p.getNumber()) + " pcs");
                        }
                        key.setStock(map);
                        return key;
                    }).collect(Collectors.toMap(KeyCustomerQueryProductPackage::getPack, a -> a, (o1, o2) -> {
                        Map map1 = o1.getStock();
                        Map map2 = o2.getStock();
                        if (map1.containsKey("上海")) {
                            map1.putAll(map2);
                            o1.setStock(map1);
                        } else {
                            map2.putAll(map1);
                            o1.setStock(map2);
                        }
                        return o1;
                    })).values().stream().collect(Collectors.toList());
                    return o;
                }).collect(Collectors.toList());

                return task;
            },executorService);

            futureTask.add(productPackageTask);
        });
        //将结果集转换为数组
        CompletableFuture<List<List<KeyCustomerQueryProductPackage>>>[] futureTaskArr = futureTask.toArray(new CompletableFuture[futureTask.size()]);
        //等待所有异步任务全部执行完毕
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureTaskArr);
        allOf.join();
        //储存处理好的结果集
        List<List<KeyCustomerQueryProductPackage>> listList = new ArrayList<>();

        for (int i = 0; i < futureTaskArr.length; i++) {
            try {
                listList.addAll(futureTaskArr[i].get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        List<List<KeyCustomerQueryProductPackage>> sortList = listList.stream().map(m ->
             m.stream().sorted((s1,s2) -> (int) (Double.valueOf(s1.getPrice()) - Double.valueOf(s2.getPrice()))).collect(Collectors.toList())
        ).collect(Collectors.toList());
        return sortList;
    }