JAVA集合框架详解(1)--整体概述

JAVA集合框架详解(1)–整体概述

前言

本文主要是将java的集合框架从多个角度进行了分类,然后分别进行概述.

本文只是概述,方便对集合框架有个整体的了解.

只有JDK中明确说明是属于集合框架的类或接口,才在本文探讨范围内.

基于JDK1.8_102.

1.概要

JDK中明确指明属于集合框架的类如下图所示:

csdn博文中图片会被压缩,可以点此访问原图:http://i.imgur.com/JqIxTMO.jpg

只有JDK中明确说明是属于集合框架的类或接口,才出现在上图中,其它的,比如 HashTable JDK有明确指出是属于Java Collection框架,但是它的子类 Properties JDK并没有明确指明,Oralce关于集合框架的官方文档中也没有明确指明 Properties 是属于集合框架.虽然理论上 Properties 也应当是属于集合框架,但是既然官方没有明确说明,从严谨的角度,就不在纳入本文的说明范围.

从图中可以明显的看出来,JAVA的集合框架大体上分为两部分:Collection 和 Map,其中 Collection 又分为了 List、Queue、Set三大类,除此之外还有一些比较零散的如 Iterator、Comparator等功能性接口,也是集合框架的一部分.

但是需要注意的是,Map本质上不是集合,只是这些接口提供了集合视图的操作,可以当作集合来处理.

2.组成

2.1 Collection 接口

Collection接口主要由两大类组成,一类是继承自 java.util.Collection 的,另一类是继承自 java.util.Map 的.

继承自Collection

其中继承自 java.util.Collection (也包含 java.util.Collection 自身)的有:

• java.util.Collection

  Collection层次结构中的根接口.一个Collection代表一组Object,也就是所谓的Collection的元素(Elements).Collection中的元素可以有重复的也可以完全不重复,可以是有序的也可以是无序的,具体看实现类怎么去实现.需要注意的是,JDK不提供该接口的任何直接实现,而是去实现定义更为具体的子接口(也就是List、Set、Queue等).但是像包(bag)和多集合(multiset)应当直接实现此接口.

  所有的Collection接口的间接实现类都应该提供两个”标准的”构造方法:一个是void的(无参的)用于创建空collection的构造方法,还有一个是参数类型为Collection的单参数构造方法,用于创建一个具有与其参数相同元素新的 collection.这样可以很方便的在不同类型的collection之间相互转换.虽然在Collection接口中没办法对这个”标准”以接口方法的形式进行约定(接TransferQueue口不能有构造函数),但是所有的直接或者间接的实现类都应当遵循这项约定.

• java.util.List

  继承自 java.util.Collection,有序元素的集合,也被称为sequence,通常允许有重复元素.

• java.util.Set

  通常意义上的Set的抽象,继承自 java.util.Collection,不允许有重复元素,可能是有序的,也可能是无序的.

• java.util.Queue

  在处理元素前用于保存元素的 collection.除了基本的 Collection 操作外,队列还提供其他的插入、提取和检查操作.

• java.util.Deque

  双端队列,一个线性 collection,支持在两端插入和移除元素.继承自 java.util.Queue .

• java.util.SortedSet

  自动排序的 Set.这些元素使用其自然顺序(参考Comparable接口的API说明)进行排序,或者根据通常在创建有序 set 时提供的 Comparator 进行排序.该 set 的迭代器将按元素升序遍历 set.

• java.util.NavigableSet

  扩展的 SortedSet,具有了为给定搜索目标报告最接近匹配项的导航方法.可以按升序或降序访问和遍历 NavigableSet.

• java.util.concurrent.BlockingQueue

  支持两个附加操作的 Queue,这两个操作是:获取元素时等待队列变为非空,以及存储元素时等待空间变得可用.隶属于java.util.concurrent 包.

• java.util.concurrent.TransferQueue

  继承自BlockingQueue,它是这样一个队列:生产者会一直阻塞直到所添加到队列的元素被某一个消费者所消费.隶属于java.util.concurrent 包.

• java.util.concurrent.BlockingDeque

  支持两个附加操作的 Deque,这两个操作是:获取元素时等待双端队列变为非空;存储元素时等待双端队列中的空间变得可用.隶属于java.util.concurrent 包.

继承自Map

继承自 java.util.Map (也包含 java.util.Map 自身)的有:

• java.util.Map

  键值对的集合.

• java.util.SortedMap

  自动排序的 Map.这些元素使用key的自然顺序(参考Comparable接口的API说明)进行排序,或者根据通常在创建有序 set 时提供的 Comparator 对key进行排序.

• java.util.NavigableMap

  扩展的 SortedMap,具有了针对给定搜索目标返回最接近匹配项的导航方法.可以按key的升序或降序访问和遍历 NavigableMap.

• java.util.ConcurrentMap

  提供原子 putIfAbsent、remove、replace 方法的Map.隶属于java.util.concurrent 包.

2.2 对Collection框架的接口的通用实现

接口	Hash table实现	Resizable array实现	Tree实现	Linked list实现	Hash table + Linked list实现
Set	HashSet		TreeSet		LinkedHashSet
List		ArrayList		LinkedList
Queue
Deque		ArrayDeque		LinkedList
Map	HashMap		TreeMap		LinkedHashMap

• java.util.HashSet

  Set 接口的Hash table实现,是Set接口最全面的实现.

• java.util.TreeSet

  NavigableSet 接口的红黑树实现.

• java.util.LinkedHashSet

  Set 接口的Hash table 结合 linked list 的实现.此链接列表定义了迭代顺序,即按照将元素插入到 set 中的顺序(插入顺序)进行迭代.此实现与 HashSet 的不同之外在于,HashSet后者维护着一个运行于所有条目的双重链接列表.

• java.util.TreeSet

  基于 TreeMap 的 NavigableSet 实现.使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法.此实现为基本操作(add、remove 和 contains)提供受保证的 log(n) 时间开销

• java.util.ArrayList

  List接口的可变数组实现(相当于非同步的Vector),是List接口最全面的实现.

• java.util.ArrayDeque

  Deque 接口的大小可变数组的实现.

• java.util.LinkedList

  List 接口的链接列表实现.在元素的插入和删除上,比ArrayList有更好的性能.同样也实现了 Deque 接口,相当于一个FIFO的队列.

• java.util.PriorityQueue

  一个基于优先级堆的无界优先级队列.优先级队列的元素按照其自然顺序进行排序,或者根据构造队列时提供的 Comparator 进行排序,具体取决于所使用的构造方法.优先级队列不允许使用 null 元素.依靠自然顺序的优先级队列还不允许插入不可比较的对象.

• java.util.HashMap

  Map接口的 Hash table 实现,相当于非同步的Hashtable.支持 null key和value.是Map接口最全面的实现.

• java.util.TreeMap

  NavigableMap 接口的红黑树实现.

• java.util.LinkedHashMap

  Map接口的 Hash table 结合 linked list 实现.此链接列表定义了迭代顺序,该迭代顺序通常就是将键插入到映射中的顺序(插入顺序).效率几乎和HashMap一样.

2.3 包装实现

主要是对其它实现的功能性增强,一般仅通过static方法来调用.

• java.util.Collections.unmodifiableInterface

  返回指定collection的一个不可修改的视图,如果用户试图修改它,那么就会抛出一个 UnsupportedOperationException.

• java.util.Collections.synchronizedInterface

  根据指定的collection(通常是非同步的),返回一个同步的collection.只要是通过返回的这个collection来访问指定的collection,那么就能保证其线程安全.

• java.util.Collections.checkedInterface

  返回指定 collection 的一个动态的类型安全的视图,如果用户尝试添加一个错误类型的元素,那么就会抛出一个ClassCastException.
  泛型是在编译期(静态)进行的类型检查,但是这种机制有可能会被忽视掉.动态的类型安全视图可以消除这种可能性.

2.4 适配器实现

用来将一种类型的collection适配为另外一种.

• java.util.Collections.newSetFromMap(Map)

  根据一个通用的Map实现,创建一个通用的Set实现.

• java.util.Collections.asLifoQueue(Deque)

  将Deque转换为后进先出(LIFO)的Queue.

2.5 方便创建集合的实现

Collection接口的高性能最小实现.

来自 java.util.Arrays 的:

• asList

  允许将一个数组转换成list.

来自 java.util.Collections 的:

• emptySet, emptyList, emptyMap

  返回一个不可变的空的set, list 或 map.

• singleton, singletonList, singletonMap

  返回一个不可变的只包含指定对象(或者是键值对)的set, list 或 map.

• nCopies

  返回一个包含指定对象n份copy的list.

2.6 早期JDK遗留下来的实现

比较老的集合类,出现的比Collection接口还早,在出现Collection接口后,才去实现的Collection接口.

• java.util.Vector

  List接口的同步可变数组实现.

• java.util.Hashtable

  Map接口的同步的hash table实现,不允许key和value为null.

2.7 专用实现

• java.util.WeakHashMap 以弱引用的key实现的基于哈希表的 Map.这样的话,当某个key在WeakHashMap外不再被引用时,就会及时的被回收.
  在registry-like(一旦没有进程使用那么这个key也就失去了作用)这样的数据结构中,比较适合使用此类.
• java.util.IdentityHashMap Map 接口的基于hash table的Identity-based实现.IdentityHashMap有其特殊用途,比如序列化或者深度复制.IdentityHashMap在对它的key做比较时,是判断引用相等(==判断),而不是调用equals方法,这也是和HashMap的一大不同之处.
• java.util.concurrent.CopyOnWriteArrayList List 接口的基于copy-on-write数组的实现.所有会引起list变化的操作(比如add, set, remove),都是通过创建数组的新的副本来实现的.不需要手动同步,甚至在迭代器迭代的过程中iterator也确保不会抛出ConcurrentModificationException.该实现比较适合去处理event-handler(不经常变化,但访问频繁并且可能比较费时)这样的列表.
• java.util.concurrent.CopyOnWriteArraySet Set 接口的基于copy-on-write数组的实现.有点类似CopyOnWriteArrayList.和大多数Set不同的是,add, remove,以及 contains方法的耗时会随着Set的大小增加而成比例的增大.适用于不能有重复的event-handler列表.
• • java.util.EnumSet 依赖于bit vector的高性能的 Set 实现.EnumSet中所有键都必须来自单个枚举类型.
• java.util.EnumMap 依赖于数组的高性能的 Map 实现.EnumMap中所有键都必须来自单个枚举类型.

2.8 同步(Concurrent)相关实现

这些实现都属于java.util.concurrent包.

• java.util.concurrent.ConcurrentLinkedQueue 一个无界的先进先出(FIFO)的基于linked nodes的队列.
• java.util.concurrent.LinkedBlockingQueue 一个可控边界的先进先出(FIFO)的基于linked nodes的队列.
• java.util.concurrent.ArrayBlockingQueue 一个有界的先进先出(FIFO)的基于数组的队列.
• java.util.concurrent.ArrayBlockingQueue 一个依赖于 priority heap 的无界阻塞队列.
• java.util.concurrent.DelayQueue 一个依赖于priority heap的time-based scheduling 队列.
• java.util.concurrent.SynchronousQueue BlockingQueue接口的一个简单的会合机制的实现.
• java.util.concurrent.LinkedBlockingDeque 一个依赖于linked nodes可控边界的 FIFO 阻塞队列.
• java.util.concurrent.LinkedTransferQueue 一个依赖于linked nodes无界的TransferQueue.
• java.util.concurrent.ConcurrentHashMap 一个基于hash table的支持高并发的高性能的 ConcurrentMap 实现.
• java.util.concurrent.ConcurrentSkipListSet NavigableSet接口的SkipList实现.
• java.util.concurrent.ConcurrentSkipListMap ConcurrentNavigableMap接口的SkipList实现.

2.9 抽象实现

collection接口的骨干实现.

• java.util.AbstractCollection Collection 接口的骨干实现,既不是set也不是list(类似”bag”或multiset).
• java.util.AbstractSet Set 接口的骨干实现.
• java.util.AbstractList List 接口的基于随机访问数据存储(比如数组)的骨干实现.
• java.util.AbstractSequentialList List 接口的基于连续访问数据存储(比如LinkedList)的骨干实现.
• java.util.AbstractQueue Queue 接口的骨干实现.
• java.util.AbstractMap Map 接口的骨干实现.

2.10 算法支持

都是 java.util.Collections 提供的静态方法.

• sort(List) - 使用混合排序算法对list进行排序,相比于高质量的快速排序,混合排序可以提供一个比较中庸的排序实现:它可以确保复杂度为O(n*log n)(不同于快速排序),同时也是稳定的排序(也不同于快速排序)–稳定是指对于相等的(equal)元素,排序后不会改变它们的顺序.

• binarySearch(List, Object) - 使用二分检索算法,在一个排序过的list中查找指定的元素.

• reverse(List) - 将list中元素的顺序进行反转.

• shuffle(List) - 随机改变list中元素的顺序.

• fill(List, Object) - 使用指定的值覆盖list中的每一个元素.

• copy(List dest, List src) - 将原list的内容复制到目标list中.

• min(Collection) - 返回集合中的最小元素.

• max(Collection) - 返回集合中的最大元素.

• rotate(List list, int distance) - 通过指定的距离进行旋转指定列表中的元素.

• replaceAll(List list, Object oldVal, Object newVal) - 将所有的指定的元素替换成另外一个新的值.

• indexOfSubList(List source, List target) - 返回source中第一个等于target的子list的索引.

• lastIndexOfSubList(List source, List target) - 返回source中最后一个等于target的子list的索引.

• swap(List, int, int) - 交换指定list中指定两个元素的位置.

• frequency(Collection, Object) - 计算指定元素在collection中出现的次数.

• disjoint(Collection, Collection) - 判断两个collection是否相交, 换句话说,它们是否包含相同的元素.

• addAll(Collection

2.11 基础性接口

• Iterators - 类似Enumeration接口,但是功能更强大.同时也是用来替代Enumeration接口的.

• Iterator - 除了 Enumeration 接口的功能之外, 还允许用户从备份的collection中移除元素.

• ListIterator - 针对list的Iterator. 除了Iterator 接口的功能之外, 还支持双向的迭代,元素替换,元素插入, 以及索引检索.

2.12 排序支持

• Comparable - 通知实现此接口的类进行自然排序. 自然排序可以用来对一个list进行排序,或者是维护有序的set或map的顺序. 为了实现此接口,很多类都进行了重写.

• Comparator - 表示一种顺序关系, 可以用来对一个list进行排序,或者是维护有序的set或map的顺序.它可以覆盖某种类型的对象原有的自然排序 或者是对并没有实现Comparable接口的某种类型的对象进行排序.

2.13 运行时异常

• java.lang.UnsupportedOperationException

  当一个不支持的可选操作被调用时,由collection抛出该异常.

• java.util.ConcurrentModificationException

  如果在迭代的过程中,所依赖的collection发生了改变,那么将会由迭代器和列表迭代器抛出该异常.当列表发生了意料之外的改变时,列表的sublist views也会抛出该异常.

2.14 性能相关

• java.util.RandomAccess

  一个标记接口,用来表明此List实现支持快速随机访问(通常是固定时间). 这可以让JDK的一些算法在访问这些list的时候,改变算法的行为,以便获取到更好的性能.

2.15 数组工具

• java.util.Arrays

  包含了一系列的静态工具方法,包括但不限于: sort, search, compare, hash, copy, resize, convert to String, and fill arrays of primitives and objects.

3.附录

3.1 Java Collection 框架所包含的类

1. java.lang.Comparable
2. java.lang.UnsupportedOperationException
3. java.util.AbstractCollection
4. java.util.AbstractList
5. java.util.AbstractMap
6. java.util.AbstractQueue
7. java.util.AbstractSequentialList
8. java.util.AbstractSet
9. java.util.ArrayDeque
10. java.util.ArrayList
11. java.util.Arrays
12. java.util.Collection
13. java.util.Collections
14. java.util.Comparator
15. java.util.Deque
16. java.util.EnumMap
17. java.util.EnumSet
18. java.util.HashMap
19. java.util.HashSet
20. java.util.Hashtable
21. java.util.IdentityHashMap
22. java.util.Iterator
23. java.util.LinkedHashMap
24. java.util.LinkedHashSet
25. java.util.LinkedList
26. java.util.List
27. java.util.ListIterator
28. java.util.Map
29. java.util.NavigableMap
30. java.util.NavigableSet
31. java.util.PriorityQueue
32. java.util.Queue
33. java.util.RandomAccess
34. java.util.Set
35. java.util.SortedMap
36. java.util.SortedSet
37. java.util.TreeMap
38. java.util.TreeSet
39. java.util.Vector
40. java.util.WeakHashMap
41. java.util.concurrent.ArrayBlockingQueue
42. java.util.concurrent.BlockingDeque
43. java.util.concurrent.BlockingQueue
44. java.util.concurrent.ConcurrentHashMap
45. java.util.concurrent.ConcurrentLinkedDeque
46. java.util.concurrent.ConcurrentLinkedQueue
47. java.util.concurrent.ConcurrentMap
48. java.util.concurrent.ConcurrentNavigableMap
49. java.util.concurrent.ConcurrentSkipListMap
50. java.util.concurrent.ConcurrentSkipListSet
51. java.util.concurrent.CopyOnWriteArrayList
52. java.util.concurrent.CopyOnWriteArraySet
53. java.util.concurrent.DelayQueue
54. java.util.concurrent.LinkedBlockingDeque
55. java.util.concurrent.LinkedBlockingQueue
56. java.util.concurrent.LinkedTransferQueue
57. java.util.concurrent.PriorityBlockingQueue
58. java.util.concurrent.SynchronousQueue
59. java.util.concurrent.TransferQueue

4.参考资料

1. Oracle collections 说明
2. JDK 1.8 API