首页 > 基础资料博客日记

JAVA基础之七-Collection和它的并行和流处理

2024-09-23 17:00:05基础资料围观10次

Java资料网推荐JAVA基础之七-Collection和它的并行和流处理这篇文章给大家，欢迎收藏Java资料网享受知识的乐趣

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为例子。

这些方法都极其简单，也没有什么特别好解释的，直接上例子吧！

package study.base.types.collection.list;

import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

/**
 * 演示Collection接口的基本操作和LinkedList的一些典型操作
 * @author lto
 */
public class TestLinkedList {
    private LinkedList<MoneyJar> list;
    private String[] givers = new String[]{"爸爸","妈妈","哥哥","姐姐","爷爷","奶奶"};
    private Random random = new Random();
    private Map<String,Long> realGivers;

    public TestLinkedList(int size) {
        this.list = new LinkedList<>();
        this.realGivers = new HashMap<>();
        //插入100个MoneyJar，金额和日期都是随机的,giver是随机
        for (int i = 0; i < size; i++) {
            String giver = givers[random.nextInt(givers.length)];
            int amount = random.nextInt(100);
            this.list.add(new MoneyJar(giver, amount, new Date()));
        }
        //按照giver分组统计个数，并赋值给realGivers
        this.list.stream().collect(Collectors.groupingBy(MoneyJar::giver,
                Collectors.counting())).forEach((k,v)->{
            realGivers.put(k,(long)v);});
        //打印realGivers
        this.realGivers.forEach((k,v)->{System.out.println(String.format("%s共有%d个", k, v));});
    }

    public void count(){
        long start = System.currentTimeMillis();
        final long[] total = {0};
        this.list.spliterator().forEachRemaining(mj-> total[0] += mj.amount());
        System.out.println(String.format("总共%d元",total[0]));
        System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
    }

    public void sortByAmount(){
        this.list.sort((o1, o2) -> o1.amount().compareTo(o2.amount()));
    }
    /**
     * 统计每个giver给的钱,并打印结果
     */
    public void sumByGiver(){
        System.out.println("--------------------****************-----------------------------");
        //根据giver分组统计每个giver给的钱,并返回一个ListMap
        long start = System.currentTimeMillis();
        Map<String, Integer> result= this.list.stream().collect(Collectors.groupingBy(MoneyJar::giver,
                Collectors.summingInt(MoneyJar::amount)));
        //打印统计结果
        result.forEach((k,v)->{System.out.println(String.format("%s给的钱是%d", k, v));});
        System.out.println("耗费时间:"+(System.currentTimeMillis()-start));

        //采用for循环的方式，分组统计
        System.out.println("采用for循环的方式，分组统计-----------------------------");
        long start1 = System.currentTimeMillis();
        Map<String,List<Integer>> result1= new HashMap<>();
        //初始化result1,把realGivers的每个元素作为key,初始值为0
         this.realGivers.forEach((k,v)->{
            result1.put(k,new ArrayList<>());
        });
        //遍历list,计算每个giver给的钱

        for (MoneyJar moneyJar : list) {
           result1.get(moneyJar.giver()).add(moneyJar.amount());
        }

        //根据result1的成员个数，创建对应的线程，然后在线程中计算每个giver给的钱,并计算总和
        int numThreads=result1.size();
        CountDownLatch latch = new CountDownLatch(numThreads);

        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        result1.forEach((k,v)->{
            Runnable worker = () -> {
                try {
                    long sum=0;
                    for (int i : v) {
                        sum+=i;
                    }
                    System.out.println(String.format("%s给的钱是%d", k, sum));
                } finally {
                    latch.countDown(); // 计数减一
                }
            };
            // 使用executor提交任务，而不是直接启动Thread
            executor.submit(worker);
        });
        try {
            // 等待所有线程完成
            latch.await();
            System.out.println("All threads have finished.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭executor，释放资源
        executor.shutdown();
        System.out.println("耗费时间:"+(System.currentTimeMillis()-start1));
    }


    public void splitToSum(){
        //把钱罐的钱分为n份,分别统计，然后再合并总的金额,并统计耗费时间
        System.out.println("--   采用并行流的方法");
        long start = System.currentTimeMillis();
        Long total=list.parallelStream().mapToLong(MoneyJar::amount).sum();
        System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
        System.out.println("总金额是"+total.toString());

        //采用传统的for循环方式累积
        System.out.println("--   采用传统的for循环的方法");
        start = System.currentTimeMillis();
        long sum=0;
        for (MoneyJar moneyJar : list) {
            sum+=moneyJar.amount();
        }
        System.out.println("总金额是"+sum);
        System.out.println("耗费时间:"+(System.currentTimeMillis()-start));
    }

    /**
     * 把小于等于指定的金额的钱都清理掉
     * @param amount
     */
    public void purgeSmallMoney(int amount){
        this.list.removeIf(moneyJar -> moneyJar.amount()<=amount);
    }

    record MoneyJar(String giver,Integer amount,
                    Date putDay){
    }

    public static void main(String[] args) {
        //当10万个的时候，并行的速度反而是for的3倍左右。
        TestLinkedList test = new TestLinkedList(200);
        test.splitToSum();
        test.sortByAmount();
        System.out.println("-- 排序后 -----");
        for (MoneyJar moneyJar : test.list) {
            System.out.println(moneyJar);
        }
        //测试100万的情况
        TestLinkedList test100 = new TestLinkedList(1000000);
        test100.splitToSum();

        //测试2000万的情况
        TestLinkedList test1000 = new TestLinkedList(20000000);
        test1000.splitToSum();

        //以上三个例子，哈无例外，都是简单的循环胜出。那么parametrizedStream的效率就值得怀疑了。
        //是否因为没有正确设置并行度，还是计算机的环境存在问题
        test1000.sumByGiver();
        test1000.count();
    }
}

以上例子并没有测试每一个接口方法，是因为有些太简单不值得浪费篇幅。

三、并行处理和流处理

在J8之前，如果把一个集合，以ArrayList为例子，进行并行处理，那么必须自己来动手，过程可能是这样的：

1.分隔集合为n个子集

2.创建n个线程，用于分别处理n个子集

3.如果需要合并处理，还需要特定注意线程的等待和合并

写起来还是相对比较麻烦的。当然，现在借助于ai，没有那么复杂。但和J8之后提供的特性相比，自然还是麻烦一些。

至于流，更不用说了，J8之前并没有这个概念。

在JDK17中，可以看到Collection接口和并发以及流有关的方法：

default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
@Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

这三个都是默认方法，可以直接使用

parallelStream可以提供并行流处理。

根据已知的一些报告和我几次不是很严谨的测试，Stream和for相比并没有什么优势。

由此可以得出一个不是很严谨的结论：

在相当大的业务场景（crud为主的信息系统）中，甚至可以说，在大部分的业务场景中，Stream其实居于下风。

stream的作用仅仅是为了节约工程师的精力和体力。

只有数据集巨大，且cpu充足的情况下，例如千万级别左右，并行流才会有一些可见的优势。但是，又有多少面向

企业基别的信息系统，会在应用级别这样疯狂地处理千万级别的数据，难道不怕jvm爆了吗？

用数据库的集合运算功能不是更好更简单吗？

四、工具类

4.1官定工具- Collections

这是集合最重要的工具类。

全路径:java.util.Collections

需要特别申明的是，Collections不仅仅会处理Colletion的子子孙孙，也会处理Map，所以不能被它的名称骗了。

由于存在JAVADOC，且这个Colllections的成员巨多，所以不逐一列出，避免浪费篇幅。

Collections方法大体包含三类：

1.运算

例如排序(sort)、翻转(reverse)、打乱(shuffle)、交换元素(swap)、填充元素(fill)，经典聚集(min,max),集合运算等等

其中和经典集合运算有关的：

frequency -频率

disjoint-判断是否有交集

总之，结合Collecion自身的实现和Collections工具，要实现两个集合的并集、交集、差集、是否包含等等都是可以的，只不过有点麻烦。

2.构造特定类型的对象

a.不可修改集合（含map)

b.线程同步集合（含map）

c.锁定类型集合

d.空集合(无元素集合)

e.单元素集合（Singleton）

前四个都容易理解，最后一个Singleton有点迷惑，就是为了返回只有一个成员的集合？

3.其它杂项

诸如复制、替换等等。

不过没有提供深度复制的方法。

4.2阿帕奇集合工具（CollectionUtils）

相比java自带的集合工具，阿帕奇的工具主要集中在以下几个用途：

1.集合运算

这个比java官方的强大多了，所以还是用这个把。看看都有什么：

union(并集)，intersection(交集),disjunction(!交集，或者独立并集),substract(移除子集),containAny(是否有交集)

isSubCollection(是否子集),isEqualCollection(是否相等),retainAll(交集),以及其它。

注意：retainAll和intersection都可以用于获取交集，但是二者还是有明显区别的,后者(intersection)会给出不重复的结果，而前者(retainAll)会给出重复的结果。

以下是关于这些本人重视的集合运算方法的示例:

public void testApacheCollectionUtils(){
        List<Integer>  me = Arrays.asList(90, 80, 70,90,92,88);
        List<Integer>  mother = Arrays.asList(90, 80, 70,90,92,88);
        List<Integer>  auntScore = Arrays.asList(90, 80, 70,90,92,88);
        List<Integer>  fatherScore = Arrays.asList(99, 81, 71,90,98,88);
        List<Integer>  赵云 = Arrays.asList(90,80);
        List<Integer>  崔颢 = Arrays.asList(77);

        List<Integer>  myNewScore = (List<Integer>) CollectionUtils.union(me, 赵云);
        System.out.println("我和赵云的合并∪="+myNewScore);
        List<Integer>  myIntersectionScore = (List<Integer>) CollectionUtils.intersection(me, fatherScore);
        System.out.println("我和爸爸交集="+myIntersectionScore);
        //差集
        List<Integer>  myDifferenceScore = (List<Integer>) CollectionUtils.subtract(me, fatherScore);
        System.out.println("我和爸爸的差集="+myDifferenceScore);
        //非公共部分
        List<Integer>  myDisJointScore = (List<Integer>) CollectionUtils.disjunction(me, fatherScore);
        System.out.println("我和爸爸的非公共部分="+myDisJointScore);

        //我和爸爸是否有交集
        if(!CollectionUtils.containsAny(me, fatherScore)) {
            System.out.println("我和爸爸没有交集");
        } else {
            System.out.println("我和爸爸有交集");
        }
        //我和崔颢是否有交集
        if(!CollectionUtils.containsAny(me, 崔颢)) {
            System.out.println("我和崔颢没有交集");
        } else {
            System.out.println("我和崔颢有交集");
        }
        //我和赵云的交集
        List<Integer>  myIntersectionScore2 = (List<Integer>) CollectionUtils.retainAll(me, 赵云);
        System.out.println("我和赵云的交集(retainAll)="+myIntersectionScore2);
        System.out.println("我和赵云的交集(inter)="+ CollectionUtils.intersection(me, 赵云));
        //和崔颢Score的交集
        List<Integer>  myIntersectionScore3 = (List<Integer>) CollectionUtils.retainAll(崔颢, 赵云);
        System.out.println("和崔颢的交集="+myIntersectionScore3);

        //赵云是否是me的子集
        if(CollectionUtils.isSubCollection(赵云, me)) {
            System.out.println("赵云是me的子集");
        } else {
            System.out.println("赵云不是me的子集");
        }
        //崔颢Score是否是me的子集
        if(CollectionUtils.isSubCollection(崔颢, me)) {
            System.out.println("崔颢是me的子集");
        } else {
            System.out.println("崔颢不是me的子集");
        }

        //妈妈和阿姨是否一致
        if(CollectionUtils.isEqualCollection(mother, auntScore)) {
            System.out.println("妈妈和阿姨一致");
        } else {
            System.out.println("妈妈和阿姨不一致");
        }
    }

输出结果：

我和赵云的合并∪=[80, 70, 88, 90, 90, 92]
我和爸爸交集=[88, 90]
我和爸爸的差集=[80, 70, 90, 92]
我和爸爸的非公共部分=[80, 81, 98, 99, 70, 71, 90, 92]
我和爸爸有交集
我和崔颢没有交集
我和赵云的交集(retainAll)=[90, 80, 90]
我和赵云的交集(inter)=[80, 90]
和崔颢的交集=[]
赵云是me的子集
崔颢不是me的子集
妈妈和阿姨一致

2.元素处理

find，filter,exists,countMatches、select、collect、get、

3.构造特定类型集合

synchronizedCollection
unmodifiableCollection
predicatedCollection
typedCollection

需要注意的是，这里的几个方法，个人倾向于少用，尽量用java标准的Collections。

4.杂项

isEmpty,isNotEmpty,cardinality...

4.3其它杂项工具

现在工具有点泛滥了。这是因为复制工具代码已经很简单，再加上实在有一些个性化的需要，所以越做越多。

Spring有，JSON有,mybatis有...

这些已经泛滥的就不提了，它们主要用于一些极其个性化的，或者自认为更有效率更安全（存疑）。

4.4 小结

为安全起见，我个人都是尽量用官方的Collections和阿帕奇的CollectionUtils。

从工程角度出发，尽量少依赖也是一个大体正确的选择。

其它的不是万不得已不要用。当然各个组织也完全可以自行创建工具。

只不过，这两个工具集已包含绝大部分集合有关的操作，再结合Stream和Colllection自有的功能，应该很够用了。

五、CRUD和集合

编写crud的时候，我们可能会常常使用以下几种基于jdbc的方式创建集合：

1.使用基于jdbc的orm,例如典型的mybatis

2.基于sping的jdbcTemplate

实际是对原生jdbc的封装

3.基于原生jdbc

现在已经很少人用jpa来访问处理数据。

在绝大部分CRUD项目中，一般都用mytabis之类的Orm

所以，这里主要讨论mybatis（或者类似的框架工具即可）。

当返回集合的时候，mytais支持返回List(ArrayList),Set ，对这两个类型的支持是很友好的。

以下是方法（org.apache.ibatis.jdbc.SqlRunner#getResults,selectAll）的部分

public List<Map<String, Object>> selectAll(String sql, Object... args) throws SQLException {
  try (PreparedStatement ps = connection.prepareStatement(sql)) {
    setParameters(ps, args);
    try (ResultSet rs = ps.executeQuery()) {
      return getResults(rs);
    }
  }
}
private List<Map<String, Object>> getResults(ResultSet rs) throws SQLException {
    List<Map<String, Object>> list = new ArrayList<>();
    .....
    while (rs.next()) {
      Map<String, Object> row = new HashMap<>();
      for (int i = 0, n = columns.size(); i < n; i++) {
        String name = columns.get(i);
        TypeHandler<?> handler = typeHandlers.get(i);
        row.put(name.toUpperCase(Locale.ENGLISH), handler.getResult(rs, name));
      }
      list.add(row);
    }
    return list;
  }

可以看出，在mybatis的底层是用ArrayList来承接原生数据集的结果的。用ArrayList是因为一个性能较好，另外一个是因为集合的数量不可测的缘故。

在不考虑极端性能的要求下，用mybatis还是不错的，因为它提供了主要的类型转换和spring的集成。

很少有人考虑使用LinkedList等其它集合来承接数据即可。

由于List实现了Collection接口，所以可以使用mybatis在获得List之后，再做流处理。

六、适用场景和挑战

集合的子孙巨多，有不同的业务场景对应，以最常见的来说：

ArrayList -- crud，随机访问性能高。但crud很少随机访问某个，一般都丢到前端处理了。

如前，Colletions提供了大量构建特定用途的集合的方法，可以让动态列表用于线程安全等场景。

LinkedList -- 双向链表用途很广，一般不CRUD的时候，常常会考虑用它，它的优缺点：

频繁进行插入和删除更高效；可以用作用作栈（Stack）和队列（Queue）；保持元素插入顺序的场景；实现双向遍历

缺点：随机访问慢

Set -大量的非crud的，需要保持元素唯一的情况

Queue -队列，主要用于需要堆栈操作的情况

再结合线程同步、不可修改、指定类型等等，可以细分为更多的子场景。

由于子孙太多，如果个人对每个类型的优缺点不是太明白，那么至少要知道大类的适用场景，然后再查看javaDoc/ai即可。

6.1 挑战-线程安全

如果，java工具Colleections已经提供了适用于大部分业务场景的并发集合对象，以便在线程操作情况下，能够保证安全。

以非常典型的java.util.Collections.synchronizedList(List<T>)为例子，下面是相关代码:

 public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

static class SynchronizedList<E>
        extends SynchronizedCollection<E>
        implements List<E> {
        @java.io.Serial
        private static final long serialVersionUID = -7754090372962971524L;

        @SuppressWarnings("serial") // Conditionally serializable
        final List<E> list;

        SynchronizedList(List<E> list) {
            super(list);
            this.list = list;
        }
        SynchronizedList(List<E> list, Object mutex) {
            super(list, mutex);
            this.list = list;
        }

        public boolean equals(Object o) {
            if (this == o)
                return true;
            synchronized (mutex) {return list.equals(o);}
        }
        public int hashCode() {
            synchronized (mutex) {return list.hashCode();}
        }

        public E get(int index) {
            synchronized (mutex) {return list.get(index);}
        }
        public E set(int index, E element) {
            synchronized (mutex) {return list.set(index, element);}
        }
        public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }
        public E remove(int index) {
            synchronized (mutex) {return list.remove(index);}
        }

        public int indexOf(Object o) {
            synchronized (mutex) {return list.indexOf(o);}
        }
        public int lastIndexOf(Object o) {
            synchronized (mutex) {return list.lastIndexOf(o);}
        }

        public boolean addAll(int index, Collection<? extends E> c) {
            synchronized (mutex) {return list.addAll(index, c);}
        }

        public ListIterator<E> listIterator() {
            return list.listIterator(); // Must be manually synched by user
        }

        public ListIterator<E> listIterator(int index) {
            return list.listIterator(index); // Must be manually synched by user
        }

        public List<E> subList(int fromIndex, int toIndex) {
            synchronized (mutex) {
                return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                            mutex);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            synchronized (mutex) {list.replaceAll(operator);}
        }
        @Override
        public void sort(Comparator<? super E> c) {
            synchronized (mutex) {list.sort(c);}
        }   
        @java.io.Serial
        private Object readResolve() {
            return (list instanceof RandomAccess
                    ? new SynchronizedRandomAccessList<>(list)
                    : this);
        }
    }

从代码可以看出，这个SynchronizedList对大部分的集合操作都使用关键字synchronized,包括基本的get,add,indexOf...

但是需要注意，并不是所有的操作都是上同步锁，例如获得迭代器（iterator()）就不会。具体哪些不会，需要工程师自己去阅读代码。

实现单个jvm内的线程安全问题不大，工程师主要的调整来自于性能要求，需要谨慎地分辨这些上锁的代价是否过于大，大到不如直接使用串行的

方式进行处理。

通常而言，如果锁内操作很短，而锁外的操作相对长的多，那么还是值得那样进行操作的。

七、小结

1.集合的子孙比较多，建议先认识一遍,这样有助于开发，不要浪费自己的时间

2.应付一般的CRUD，依靠JAVA和阿帕奇的已经基本够了用了。

如果实在不够可以自己额外编写工具集，不推荐采用三方的工具集（存在安全和更新问题）当然类似阿帕奇这样的可以例外。

如果是开发产品，更不推荐采用非知名的小组织/个人的工具包。

3.需要注意线程安全情况下的用法，这个有赖于个人实践之后的体验，虽然JAVADOC有一些说明，但是不够。

4.使用ai辅助编写代码的时候，应该有适当的辨别能力，避免每个集合都是stream()之后再操作

最简单的，例如 list.filter(),没有必要list.stream().filter,除非filter后还挂着其它操作。sort()也是类似。

不能太机械。

文章来源:https://www.cnblogs.com/lzfhope/p/18408762
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！

标签：

上一篇：阿里面试让聊一聊Redis 的内存淘汰（驱逐）策略
下一篇：代理模式 - 动态代理

首页 > 基础资料博客日记

JAVA基础之七-Collection和它的并行和流处理

一、简介

二、集合的基本方法

三、并行处理和流处理

四、工具类

4.1官定工具- Collections

4.2阿帕奇集合工具（CollectionUtils）

4.3其它杂项工具

4.4 小结

五、CRUD和集合

六、适用场景和挑战

6.1 挑战-线程安全

七、小结

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > 基础资料 博客日记

JAVA基础之七-Collection和它的并行和流处理

一、简介

二、集合的基本方法

三、并行处理和流处理

四、工具类

4.1官定工具- Collections

4.2阿帕奇集合工具（CollectionUtils）

4.3其它杂项工具

4.4 小结

五、CRUD和集合

六、适用场景和挑战

6.1 挑战-线程安全

七、小结

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > 基础资料博客日记