为知笔记

2022-12-23

需求前提

校验当前签收数量与本批送出数量是否一致，不一致给出缺少信息,关键词两个list

代码展示


public List<RecMrIndexBySendOutBatchNoListResponse> saveBatchPaperRecevieByCheck(RecMrIndexReceiveRequest request) {

List<RecMrIndexEntity> recMrIndexEntityList=request.getRecMrIndexEntities().stream()
    .filter(i->i.getSendOutBatchNo()!=null).collect(Collectors.toList());
List<RecMrIndexBySendOutBatchNoListResponse> checkResponseList=new ArrayList<>();
         
//去除重复的送出号,去除为null的
List<String> batchNoList = recMrIndexEntityList.stream().map(RecMrIndexEntity::getSendOutBatchNo).distinct().collect(Collectors.toList());
if (CollectionUtils.isEmpty(batchNoList)){
      return checkResponseList;
}
for (int i = 0; i < batchNoList.size(); i++) {
String batchNo =batchNoList.get(i);
if (StrUtil.isNotBlank(batchNo)){
List<RecMrIndexEntity> list=recMrIndexEntityList.stream()
    .filter((recMrIndex)->recMrIndex.getSendOutBatchNo().equals(batchNo))
    .collect(Collectors.toList());

List<RecMrIndexBySendOutBatchNoListResponse> selectResponseList =baseMapper.getListBySendOutBatchNo(batchNo);
if(list.size()==selectResponseList.size()){
         continue;
}else{
RecMrIndexBySendOutBatchNoListResponse selectResponse;
Iterator<RecMrIndexBySendOutBatchNoListResponse> iterator= selectResponseList.iterator();
                while (iterator.hasNext()){
                    selectResponse= iterator.next();
                    for (RecMrIndexEntity oldEntity:list){
                        if (selectResponse.getPatientId().equals(oldEntity.getPatientId()) 
                        && selectResponse.getVisitNo().equals(oldEntity.getVisitNo())){
                            iterator.remove();
                        }
                    }
                }
            //合并过滤后的数据
            checkResponseList.addAll(selectResponseList);
            }
           }
        }
//再去除一次重复数据
return  checkResponseList.stream().distinct().collect(Collectors.toList());

这个代码块的主要是对于Steam流的一些简单使用,通过Stream流可以快速得到送出号的列表,并且去除重复元素和空元素,再采用迭代器去除和另一个List中相同的元素,得到新的列表

阅读全文

Java异步回调实例(CompletableFutrue)

编辑

2022-12-21

学习记录

前言😚

以前需要异步执行一个任务时，一般是用Thread或者线程池Executor去创建。如果需要返回值，则是调用Executor.submit获取Future。但是多个线程存在依赖组合，我们又能怎么办？可使用同步组件CountDownLatch、CyclicBarrier等；其实有简单的方法，就是用CompeletableFuture

线程任务的创建
线程任务的串行执行
线程任务的并行执行
处理任务结果和异常
多任务的简单组合
取消执行线程任务
任务结果的获取和完成与否判断

1 创建异步线程任务

根据supplier创建CompletableFuture任务

java
//使用内置线程ForkJoinPool.commonPool()，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
//指定自定义线程，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

根据runnable创建CompletableFuture任务

java
//使用内置线程ForkJoinPool.commonPool()，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable)
//指定自定义线程，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

使用示例

java
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture<Void> rFuture = CompletableFuture
        .runAsync(() -> System.out.println("hello siting"), executor);
//supplyAsync的使用
CompletableFuture<String> future = CompletableFuture
        .supplyAsync(() -> {
            System.out.print("hello ");
            return "siting";
        }, executor);

//阻塞等待，runAsync 的future 无返回值，输出null
System.out.println(rFuture.join());
//阻塞等待
String name = future.join();
System.out.println(name);
executor.shutdown(); // 线程池需要关闭
--------输出结果--------
hello siting
null
hello siting

2022-12-15

什么是并行流？

简单来说，并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。 Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

Fork/Join 框架

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总。

Fork/Join 框架与传统线程池有啥区别？

采用 “工作窃取”模式（work-stealing）：

当执行新的任务时它可以将其拆分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架的实现中，如果某个子任务由于等待另外一个子任务的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子任务来执行。这种方式减少了线程的等待时间，提高了程序的性能。

2022-12-13

为什么要使用lambda表达式（函数式接口）