[Java]集合的小抄 Java初学者必备

【背景】

在尽可能短的篇幅里,将所有集合与并发集合的特征,实现方式,性能捋一遍。适合所有”精通Java”其实还不那么自信的人阅读。

Collection
Collections

Set 和List 都继承了Conllection,Map没有
Collection接口的方法

  • boolean add(Object o) :向集合中加入一个对象的引用
  • void clear() :删除集合中所有的对象,即不再持有这些对象的引用
  • boolean isEmpty() :判断集合是否为空
  • boolean contains(Object o): 判断集合中是否持有特定对象的引用
  • Iterartor iterator() : 返回一个Iterator对象,可以用来遍历集合中的元素
  • boolean remove(Object o):从集合中删除一个对象的引用
  • int size() :返回集合中元素的数目
  • Object[] toArray() :返回一个数组,该数组中包括集合中的所有元素
  • 关于:Iterator() 和toArray() 方法都用于集合的所有的元素,前者返回一个Iterator对象,后者返回一个包含集合中所有元素的数组。
    Iterator接口声明了如下方法:
  • hasNext(): 判断集合中元素是否遍历完毕,如果没有,就返回true
  • next() :返回下一个元素
  • remove():从集合中删除上一个有next()方法返回的元素。
    Set 的 add()方法是如何判断对象是否已经存放在集合中?
    boolean isExists=false;
    Iterator iterator=set.iterator();
    while(it.hasNext())           {
    String oldStr=it.next();
    if(newStr.equals(oldStr)){
    isExists=true;
    }

List

  • List的特征是其元素以线性方式存储,集合中可以存放重复对象。
ArrayList
  • 以数组实现。节约空间,但数组有容量限制。
  • 超出限制时会增加50%容量,默认第一次插入元素时创建大小为10的数组。
优势操作
  • get(i)/set(i,e) 访问
  • add(e) 末尾插入
劣势操作

System.arraycopy()来移动部分受影响的元素,性能变差

  • add–add(i,e) 按下标插入
  • add(i,e), remove(i), remove(e) 删除元素
LinkedList
  • 以双向链表实现,链表无容量限制
  • 双向链表本身使用了更多空间,需要额外的链表指针操作
优势

在链表两头的操作能省掉指针的移动

  • add()
  • addFirst()
  • removeLast()
  • iterator()上的remove()
劣势
  • 按下标访问元素–get(i)/set(i,e) 要遍历链表将指针移动到位(如果i>数组大小的一半,会从末尾移起)
  • 插入、删除元素时修改前后节点的指针即可,仍要遍历部分链表的指针才能移动到下标所指的位置
最基本的两种检索集合中的所有对象的方法:
1: 用for循环和get()方法:
   for(int i=0; i
CopyOnWriteArrayList
  • 支持读多写少的并发情况
    -增加了addIfAbsent(e)方法,会遍历数组来检查元素是否已存在,性能可想像的不太好
  • 如果更新频率较高,或数组较大时使用Collections.synchronizedList(list),对所有操作用同一把锁来保证线程安全更好
补充说明
  • 按值返回下标–contains(e), indexOf(e), remove(e) 都需遍历所有元素进行比较,性能可想像的不太好
  • 没有按元素值排序的SortedList,在线程安全类中也没有无锁算法的ConcurrentLinkedList,凑合着用Set与Queue中的等价类时,会缺少一些List特有的方法

Map

  • Map 是一种把键对象和值对象映射的集合,它的每一个元素都包含一对键对象和值对象,键对象不允许重复。
  • Map没有继承于Collection接口
  • 从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。
Map 的常用方法:
 1 添加,删除操作:
 Object put(Object key, Object value): 向集合中加入元素
 Object remove(Object key):   删除与KEY相关的元素
 void putAll(Map t):   将来自特定映像的所有元素添加给该映像
 void clear(): 从映像中删除所有映射
 2 查询操作:
 Object get(Object key): 获得与关键字key相关的值
HashMap
  • 以Entry[]数组实现的哈希桶数组,用Key的哈希值取模桶数组的大小可得到数组下标
  • 插入元素时,如果两条Key落在同一个桶(如哈希值1和17取模16后都属于第一个哈希桶)。Entry用一个next属性实现多个Entry以单向链表存放,后入桶的Entry将next指向桶当前的Entry
  • 查找key时(如哈希值为17的),先定位到第一个哈希桶,然后以链表遍历桶里所有元素,逐个比较其key值
  • 当Entry数量达到桶数量的75%时(很多文章说使用的桶数量达到了75%,但看代码不是),会成倍扩容桶数组,并重新分配所有原来的Entry
LinkedHashMap
  • 扩展HashMap增加双向链表的实现(最占内存的数据结构)
  • 支持iterator()时按Entry的插入顺序来排序(但是更新不算, 如果设置accessOrder属性为true,则所有读写访问都算)
    实现上是在Entry上再增加属性before/after指针,插入时把自己加到Header Entry的前面去。
    如果所有读写访问都要排序,还要把前后Entry的before/after拼接起来以在链表中删除掉自己
TreeMap
  • 以红黑树实现,篇幅所限详见入门教程
  • 支持iterator()时按Key值排序,可按实现了Comparable接口的Key的升序排序,或由传入的Comparator控制。
  • 可想象的,在树上插入/删除元素的代价一定比HashMap的大
    -支持SortedMap接口,如firstKey(),lastKey()取得最大最小的key,或sub(fromKey, toKey), tailMap(fromKey)剪取Map的某一段
ConcurrentHashMap
  • 并发优化的HashMap,默认16把写锁(可以设置更多),有效分散了阻塞的概率,而且没有读锁(因为put/remove动作是个原子动作(比如put是一个对数组元素/Entry 指针的赋值操作),读操作不会看到一个更新动作的中间状态)
  • 数据结构为Segment[],Segment里面才是哈希桶数组,每个Segment一把锁。Key先算出它在哪个Segment里,再算出它在哪个哈希桶里
  • 支持ConcurrentMap接口,如putIfAbsent(key,value)与相反的replace(key,value)与以及实现CAS的replace(key, oldValue, newValue)
ConcurrentSkipListMap
  • JDK6新增的并发优化的SortedMap,以SkipList实现
  • SkipList是红黑树的一种简化替代方案,是个流行的有序集合算法,篇幅所限见入门教程
  • Concurrent包选用它是因为它支持基于CAS的无锁算法,而红黑树则没有好的无锁算法
  • 它的size()不能随便调,会遍历来统计,效率低
补充说明
关于null
  • HashMap和LinkedHashMap是随意的,
  • TreeMap没有设置Comparator时key不能为null;
  • ConcurrentHashMap在JDK7里value不能为null,JDK8里key与value都不能为null;
  • ConcurrentSkipListMap是所有JDK里key与value都不能为null

Set

  • Set对每个对象只接受一次,并使用自己内部的排序方法
  • Set几乎都是内部用一个Map来实现, 因为Map里的KeySet就是一个Set,而value是假值,全部使用同一个Object。
  • Set的特征也继承了那些内部Map实现的特征。
Set接口主要实现了两个实现类:
  • HashSet : HashSet类按照哈希算法来存取集合中的对象,存取速度比较快,内部是HashMap
  • TreeSet : TreeSet类实现了SortedSet接口,能够对集合中的对象进行排序。
  • LinkedHashSet:内部是LinkedHashMap。
  • ConcurrentSkipListSet:内部是ConcurrentSkipListMap的并发优化的SortedSet。
  • CopyOnWriteArraySet:内部是CopyOnWriteArrayList的并发优化的Set,利用其addIfAbsent()方法实现元素去重,如前所述该方法的性能很一般。
补充说明
  • 好像少了个ConcurrentHashSet,本来也该有一个内部用ConcurrentHashMap的简单实现,但JDK偏偏没提供。Jetty就自己封了一个,Guava则直接用java.util.Collections.newSetFromMap(new ConcurrentHashMap()) 实现

Jetty 是一个开源的servlet容器,它为基于Java的web容器
Guava是一种基于开源的Java库,谷歌很多项目使用它的很多核心库

Queue

Queue是在两端出入的List,所以也可以用数组或链表来实现。

–普通队列–

LinkedList
  • 以双向链表实现的LinkedList既是List,也是Queue。
  • 它是唯一一个允许放入null的Queue。
ArrayDeque
  1. 以循环数组实现的双向Queue。大小是2的倍数,默认是16。

  2. 普通数组只能快速在末尾添加元素,为了支持FIFO,从数组头快速取出元素,就需要使用循环数组n有队头队尾两个下标:

  • 弹出元素时,队头下标递增;
  • 加入元素时,如果已到数组空间的末尾,则将元素循环赋值到数组0,同时队尾下标指向0,再插入下一个元素则赋值到数组[1],队尾下标指向1。
  • 如果队尾的下标追上队头,说明数组所有空间已用完,进行双倍的数组扩容。
PriorityQueue
  • 用二叉堆实现的优先级队列,详见入门教程
  • 不再是FIFO而是按元素实现的Comparable接口或传入Comparator的比较结果来出队,数值越小,优先级越高,越先出队
  • 注意其iterator()的返回不会排序。

–线程安全的队列–

ConcurrentLinkedQueue/ConcurrentLinkedDeque
  • 无界的并发优化的Queue,基于链表,实现了依赖于CAS的无锁算法。

  • ConcurrentLinkedQueue的结构是单向链表和head/tail两个指针,因为入队时需要修改队尾元素的next指针,以及修改tail指向新入队的元素两个CAS动作无法原子,所以需要的特殊的算法,篇幅所限见入门教程。

PriorityBlockingQueue
  • 无界的并发优化的PriorityQueue,也是基于二叉堆。
  • 使用一把公共的读写锁。虽然实现了BlockingQueue接口,其实没有任何阻塞队列的特征,空间不够时会自动扩容。
DelayQueue
  • 内部包含一个PriorityQueue,同样是无界的。

  • 元素需实现Delayed接口,每次调用时需返回当前离触发时间还有多久,小于0表示该触发了。

  • pull()时会用peek()查看队头的元素,检查是否到达触发时间。ScheduledThreadPoolExecutor用了类似的结构。

–线程安全的阻塞队列–

  • BlockingQueue的队列长度受限,用以保证生产者与消费者的速度不会相差太远,避免内存耗尽
  • 队列长度设定后不可改变
  • 当入队时队列已满,或出队时队列已空,不同函数的效果见下表:
ArrayBlockingQueue
  • 定长的并发优化的BlockingQueue,基于循环数组实现。
  • 有一把公共的读写锁与notFull、notEmpty两个Condition管理队列满或空时的阻塞状态。
LinkedBlockingQueue/LinkedBlockingDeque
  • 可选定长的并发优化的BlockingQueue,基于链表实现,所以可以把长度设为Integer.MAX_VALUE。
  • 利用链表的特征,分离了takeLock与putLock两把锁,继续用notEmpty、notFull管理队列满或空时的阻塞状态。
补充说明

JDK7有个LinkedTransferQueue,transfer(e)方法保证Producer放入的元素,被Consumer取走了再返回,比SynchronousQueue更好,有空要学习下。

来源:http://www.topthink.com/topic/11679.html

你可能感兴趣的:([Java]集合的小抄 Java初学者必备)