分享幾個實用的方法

　　今天主要和大家分享的是本人總結的分頁執行方法，也可以說就是分批執行；該篇採用java8新增的表示式來操作，希望能給各位帶來好的幫助和在日常工作中提供便利；同樣的操作流程和邏輯之前用C#程式碼寫過一次，有需要的朋友可以看以前的博文；

• 分頁方式拆分List為多個子集List方法
• 執行統一方法-無返回值，關鍵字：Consumer
• 執行統一方法-有返回值，關鍵字：Function
• 分批並行執行方法 採用：Executors+分頁方法

分頁方式拆分List為多個子集List方法

　　這裡我將會分享兩種拆分的方法，一種傳統subList來分割list資料，一種採用stream流來拆分；先來看第一種整體程式碼：

/**
     * list 分成多個子集list
     * @param list
     * @param pageCount 總頁數 ，如果list條數不夠，根據list條數來
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> funcToPage(List<T> list, int pageCount) {

        int currentCount = list.size();
        //總頁數 真實執行緒數
        int page = pageCount >= currentCount ? currentCount : pageCount;
        //每頁條數
        int pageSize = currentCount / page;

        List<List<T>> pageList = new ArrayList<>();
        for (int i = 0; i < page; i++) {
            //subList分頁
            List<T> lastT = new ArrayList<>();
            //分頁部分
            lastT.addAll(list.subList(i * pageSize, (i + 1) * pageSize));

            //把剩餘部分沒拆到每批次中
            if (page * pageSize + i < currentCount) {
                lastT.addAll(list.subList(page * pageSize + i, page * pageSize + i + 1));
            }

            pageList.add(lastT);
        }
        return pageList;
    }

　　這裡通過按分頁的方式來分割list資料，分頁幾乎是每個系統都會用到的方式；再來看看新特性分割的方法：

public static <T> List<List<T>> funcToPage(List<T> list, int pageCount) {

        int currentCount = list.size();
        //總頁數 真實執行緒數
        int page = pageCount >= currentCount ? currentCount : pageCount;
        //每頁條數
        int pageSize = currentCount / page;

        List<List<T>> pageList = new ArrayList<>();
        for (int i = 0; i < page; i++) {

            //採用流方式分頁
            List<T> lastPage = list.stream().
                    skip(i * pageSize).
                    limit(pageSize).
                    collect(Collectors.toList());

            if (page * pageSize + i < currentCount) {
                lastPage.add(
                        list.stream().
                                skip(page * pageSize + i).
                                limit(1).
                                findFirst().
                                get()
                );
            }
            pageList.add(lastPage);
        }
        return pageList;
    }

　　通過stream流藍分割，這裡用到了skip()，limit()兩個方法來分頁，這兩方法分別表示：跳到某條資料開始和限制多少條資料，最後有個findFirst()方法表示：查詢第一條資料，看起來和C#的linq寫法類似；

執行統一方法-無返回值，關鍵字：Consumer

　　這裡要分享的關於list（當然也可以是其他）資料迴圈執行某個方法，這裡用到了Consumer提供的accept方法來接受引數，程式碼如下：

/**
     * list 不返回值
     * @param list     資料來源
     * @param consumer
     * @param <T>      引數型別
     */
    public static <T> void funcToNoResult(List<T> list, Consumer<T> consumer) {
        list.forEach(b -> consumer.accept(b));
    }

　　測試用例：

 List<Integer> list = Arrays.asList(1, 2, 3);
 FuncUtil.funcToNoResult(list, b -> {
     System.out.println("funcToNoResult這是：" + b);
 });

　　

執行統一方法-有返回值，關鍵字：Function

　　和上面一樣這個方法也主要是對list資料在某個表示式中操作，但是該方法有返回值的概念，就是說先通過執行了表示式後，能夠得到執行的返回結果：

 /**
     * list 有返回值
     * @param list     資料來源
     * @param function
     * @param <T>      引數型別
     * @param <V>      返回型別
     * @return
     */
    public static <T, V> List<V> funcToResult(List<T> list, Function<T, V> function) {
        List<V> results = new ArrayList<>();
        list.forEach(b -> results.add(function.apply(b)));
        return results;
    }

　　關鍵字Function，要得到返回值主要是通過function.apply(b)方法來獲取，如下測試用例：

FuncUtil.funcToResult(list, b -> {
     return "funcToResult這是：" + b;
}).forEach(b -> System.out.println(b));

　　

分批並行執行方法 採用：Executors+分頁方法

　　 這裡來到今天分享的重點，該方法主要可拆分為以下幾個步驟：分批資料來源-》分批並行執行-》合併結果；分配資料採用的就是上面的分頁方法，下面具體看程式碼：

/**
     * 分批執行方法 採用：Executors+分頁方法
     * @param list           資料來源
     * @param function       處理方法 lamda表示式
     * @param maxThreadCount 處理執行緒數量
     * @param <T>            引數型別
     * @param <V>            返回型別
     * @return 處理完成結果集
     */
    public static <T, V> List<V> funcToExecutorPageSubmits(List<T> list, Function<T, V> function, int maxThreadCount) {
        List<V> results = new ArrayList<>();

        if (list == null || list.isEmpty()) {
            return results;
        }

        maxThreadCount = maxThreadCount <= 0 ? 1 : maxThreadCount;
        maxThreadCount = maxThreadCount >= 10 ? 10 : maxThreadCount;

        //分批資料來源
        List<List<T>> pageList = funcToPage(list, maxThreadCount);

        //分批並行執行
        List<Future<List<V>>> futures = new ArrayList<>();
        ExecutorService executorService = Executors.newFixedThreadPool(pageList.size());
        pageList.forEach(items -> {
            futures.add(
                    executorService.submit(() -> {
                        List<V> childResults = new ArrayList<>();
                        items.forEach(item -> childResults.add(function.apply(item)));
                        return childResults;
                    })
            );
        });

        //合併結果
        futures.forEach(b -> {
            try {
                results.addAll(b.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        return results;
    }

　　並行執行就是用了ExecuteService+Future來接受結果，通過executorService.submit()提交執行某一批次資料需要執行的方法，最後再彙總結果；

　　因為有這種常見的場景：某一批資料或者url需要在執行某個按鈕事件時去呼叫第三方介面並同步返回資料給介面使用者，因此就有了上面方法的設計和產生。就目前該方法已被我用在了生產環境中，暫無什麼異常或者問題；以下是測試用例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
FuncUtil.funcToExecutorPageSubmits(
       //資料來源
       list  
       ,
       //待執行方法
       b -> {
               return Thread.currentThread().getName() + "：" + b;
       },
       6).
        //輸出返回結果
      forEach(b -> System.out.println(b));