统计分析大文本、合并两个有序数组

package com.common.bigData.last;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;
import java.util.concurrent.*;

public class LastDemo {
    private static Logger logger = LoggerFactory.getLogger(LastDemo.class);

    public static void main(String[] args) {
        List<Map.Entry<String, Integer>> mapList = new ArrayList<>();
        ConcurrentLinkedDeque concurrentLinkedDeque = new ConcurrentLinkedDeque();
//        ExecutorService executorService=new ThreadPoolExecutor(10,20,
//                60, TimeUnit.SECONDS,
//                new  LinkedBlockingQueue<>(),
//                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
        ExecutorService executorService=Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            TaskCallable callable = new TaskCallable(i + "");
            Future f = executorService.submit(callable);
            concurrentLinkedDeque.addFirst(f);
        }
        logger.info("concurrentLinkedDeque.size "+concurrentLinkedDeque.size()+"");
        while (concurrentLinkedDeque.size() > 0) {
            Future<Map<String, Integer>> first = (Future<Map<String, Integer>>) concurrentLinkedDeque.getFirst();
            if (first.isDone()) { //保证任务执行完删除队列
                try {
                    Map<String, Integer> map = (Map<String, Integer>) first.get();
                    List<Map.Entry<String, Integer>> map2 = new ArrayList<>(map.entrySet());
                    mapList.addAll(map2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
                concurrentLinkedDeque.removeFirst();//在队列里删除该结果
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        List list2 =order(mapList);
        logger.info("over " + list2);
    }


    public static List order(List<Map.Entry<String,Integer>> mapList){
        Collections.sort(mapList, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue()-o1.getValue();
            }
        });
        return mapList;
    }



    public static class TaskCallable  implements Callable {
        String id;

        public TaskCallable(String id) {
            this.id = id;
        }

        @Override
        public Object call() throws Exception {
            return single(Integer.parseInt(id));
        }

        private   Map<String,Integer> single(int i){
            logger.info("single "+i);
            Map<String,Integer> map=new HashMap<>();
            map.put(i+"a",i);
            map.put(i+"b",i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return map;
        }
    }
}

 

 /**
     * 循环
     * 合并两个有序数组
     * */
    private static int[] mergeArrary(int[] A,int[] B){
        int[] C=new int[A.length+B.length];
        int i=0,j=0,k=0;
        while (i<A.length && j<B.length){
            if (A[i]<=B[j]){
                C[k]=A[i];
                i++;
            }else {
                C[k]=B[j];
                j++;
            }
            k++;
        }
        for (int i1=0;i1<A.length+B.length;i1++){
            System.out.println(C[i1]);
        }
        return null;
    }


/**
     * 递归
     * **/
    private static int[] compareDG(int[] a,int i, int[] b,int j,int[] c,int k) {
        if (i+j==c.length){
            return c;
        }else if (a.length==i){
            c[k++]=b[j++];
        }else if (b.length==j){
            c[k++]=a[i++];
        }else {
            if (a[i]<b[j]){
                c[k++]=a[i++];
            }else {
                c[k++]=b[j++];
            }
        }
        return compareDG(a,i,b,j,c,k);
    }