JAVA根本之七-Collection和它的并行和流处理

Collection 翻下词典，有很多含义：
收集；聚集；(常指同类的)收藏品；募捐，募集；作品集；聚积；取走；一群人；拿走；（常为季节性推出的）系列时装（或家用品）；一批物品
选择“聚集”作为翻译名，我以为可行，除非我们现在重新创造一个汉语词组。
 
对于CRUD和非CRUD，聚集都是一个无比重要的东西，因为计算机的本质是对信息的处理。
信息一般不是单个，是一堆，一堆堆，一块块，一个个....
 
网上关于聚集的资料无比多，所以本文主要是做一个简要的介绍，并添加一些注意事项和个人感悟。
 
一、简介

不外Collection的子孙过于多，用现有词汇命名这些子孙并不容易，有待创建新的词汇。
常用知名子孙有：
List  --  列表，javaDoc的释义是：有序聚集。
   --ArrayList   动态大小列表 ，这是crud中最常用的范例 。不包管顺序
   --LinkedList  双链列表,可以固定成员顺序。本身实现了Deque的接口，可用于辅助实现FiLo的算法
Set  - 无重复聚集，允许有一个null成员
  ---TreeSet   有序聚集
  -- HastSet  哈希聚集  ,主要是操纵的性能好一些
    -- LinkedHashSet  双向链哈希聚集,保持了插入顺序，又具有对应的性能
Queue -队列
   --Deque  双端操纵队列。它有一个著名的实现  LinkedList
Buffer --缓冲
  不外这个主要是阿帕奇的实现org.apache.commons.collections.Buffer，算不得java的根本范例
 
如果是初级程序员，大概以CRUD为主的，那么只要学些掌握ArrayList就差不多了，因为现在的大部分的ORM大概JDBC的上级实现都适用ArrayList来存储数据集。
 
二、聚集的基本方法

仅仅介绍Collection的接口方法，为了便于理解，以LinkedList为例子。
这些方法都极其简单，也没有什么特别好解释的，直接上例子吧！

1. package study.base.types.collection.list;
3. import java.util.*;
4. import java.util.concurrent.CountDownLatch;
5. import java.util.concurrent.ExecutorService;
6. import java.util.concurrent.Executors;
7. import java.util.stream.Collectors;
9. /**
10. * 演示Collection接口的基本操作和LinkedList的一些典型操作
11. * @author lto
12. */
13. public class TestLinkedList {
14.     private LinkedList<MoneyJar> list;
15.     private String[] givers = new String[]{"爸爸","妈妈","哥哥","姐姐","爷爷","奶奶"};
16.     private Random random = new Random();
17.     private Map<String,Long> realGivers;
19.     public TestLinkedList(int size) {
20.         this.list = new LinkedList<>();
21.         this.realGivers = new HashMap<>();
22.         //插入100个MoneyJar，金额和日期都是随机的,giver是随机
23.         for (int i = 0; i < size; i++) {
24.             String giver = givers[random.nextInt(givers.length)];
25.             int amount = random.nextInt(100);
26.             this.list.add(new MoneyJar(giver, amount, new Date()));
27.         }
28.         //按照giver分组统计个数，并赋值给realGivers
29.         this.list.stream().collect(Collectors.groupingBy(MoneyJar::giver,
30.                 Collectors.counting())).forEach((k,v)->{
31.             realGivers.put(k,(long)v);});
32.         //打印realGivers
33.         this.realGivers.forEach((k,v)->{System.out.println(String.format("%s共有%d个", k, v));});
34.     }
36.     public void count(){
37.         long start = System.currentTimeMillis();
38.         final long[] total = {0};
39.         this.list.spliterator().forEachRemaining(mj-> total[0] += mj.amount());
40.         System.out.println(String.format("总共%d元",total[0]));
41.         System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
42.     }
44.     public void sortByAmount(){
45.         this.list.sort((o1, o2) -> o1.amount().compareTo(o2.amount()));
46.     }
47.     /**
48.      * 统计每个giver给的钱,并打印结果
49.      */
50.     public void sumByGiver(){
51.         System.out.println("--------------------****************-----------------------------");
52.         //根据giver分组统计每个giver给的钱,并返回一个ListMap
53.         long start = System.currentTimeMillis();
54.         Map<String, Integer> result= this.list.stream().collect(Collectors.groupingBy(MoneyJar::giver,
55.                 Collectors.summingInt(MoneyJar::amount)));
56.         //打印统计结果
57.         result.forEach((k,v)->{System.out.println(String.format("%s给的钱是%d", k, v));});
58.         System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
60.         //采用for循环的方式，分组统计
61.         System.out.println("采用for循环的方式，分组统计-----------------------------");
62.         long start1 = System.currentTimeMillis();
63.         Map<String,List<Integer>> result1= new HashMap<>();
64.         //初始化result1,把realGivers的每个元素作为key,初始值为0
65.          this.realGivers.forEach((k,v)->{
66.             result1.put(k,new ArrayList<>());
67.         });
68.         //遍历list,计算每个giver给的钱
70.         for (MoneyJar moneyJar : list) {
71.            result1.get(moneyJar.giver()).add(moneyJar.amount());
72.         }
74.         //根据result1的成员个数，创建对应的线程，然后在线程中计算每个giver给的钱,并计算总和
75.         int numThreads=result1.size();
76.         CountDownLatch latch = new CountDownLatch(numThreads);
78.         ExecutorService executor = Executors.newFixedThreadPool(numThreads);
79.         result1.forEach((k,v)->{
80.             Runnable worker = () -> {
81.                 try {
82.                     long sum=0;
83.                     for (int i : v) {
84.                         sum+=i;
85.                     }
86.                     System.out.println(String.format("%s给的钱是%d", k, sum));
87.                 } finally {
88.                     latch.countDown(); // 计数减一
89.                 }
90.             };
91.             // 使用executor提交任务，而不是直接启动Thread
92.             executor.submit(worker);
93.         });
94.         try {
95.             // 等待所有线程完成
96.             latch.await();
97.             System.out.println("All threads have finished.");
98.         } catch (InterruptedException e) {
99.             e.printStackTrace();
100.         }
101.         // 关闭executor，释放资源
102.         executor.shutdown();
103.         System.out.println("耗费时间:"+(System.currentTimeMillis()-start1));
104.     }
107.     public void splitToSum(){
108.         //把钱罐的钱分为n份,分别统计，然后再合并总的金额,并统计耗费时间
109.         System.out.println("--   采用并行流的方法");
110.         long start = System.currentTimeMillis();
111.         Long total=list.parallelStream().mapToLong(MoneyJar::amount).sum();
112.         System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
113.         System.out.println("总金额是"+total.toString());
115.         //采用传统的for循环方式累积
116.         System.out.println("--   采用传统的for循环的方法");
117.         start = System.currentTimeMillis();
118.         long sum=0;
119.         for (MoneyJar moneyJar : list) {
120.             sum+=moneyJar.amount();
121.         }
122.         System.out.println("总金额是"+sum);
123.         System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
124.     }
126.     /**
127.      * 把小于等于指定的金额的钱都清理掉
128.      * @param amount
129.      */
130.     public void purgeSmallMoney(int amount){
131.         this.list.removeIf(moneyJar -> moneyJar.amount()<=amount);
132.     }
134.     record MoneyJar(String giver,Integer amount,
135.                     Date putDay){
136.     }
138.     public static void main(String[] args) {
139.         //当10万个的时候，并行的速度反而是for的3倍左右。
140.         TestLinkedList test = new TestLinkedList(200);
141.         test.splitToSum();
142.         test.sortByAmount();
143.         System.out.println("-- 排序后 -----");
144.         for (MoneyJar moneyJar : test.list) {
145.             System.out.println(moneyJar);
146.         }
147.         //测试100万的情况
148.         TestLinkedList test100 = new TestLinkedList(1000000);
149.         test100.splitToSum();
151.         //测试2000万的情况
152.         TestLinkedList test1000 = new TestLinkedList(20000000);
153.         test1000.splitToSum();
155.         //以上三个例子，哈无例外，都是简单的循环胜出。那么parametrizedStream的效率就值得怀疑了。
156.         //是否因为没有正确设置并行度，还是计算机的环境存在问题
157.         test1000.sumByGiver();
158.         test1000.count();
159.     }
160. }

复制代码