java 集合框架

目录

• java集合框架[^目录]
  • 目录图
  • 框架图
  • List
    • 相关接口
      • List extends Collection接口
      • Queue接口（队列）
      • Deque extends Queue 接口（双端队列）
    • ArrayList
    • LinkedList
    • Vector
    • Stack
  • Map
    • 相关接口
      • Map
    • HashMap
    • LinkedHashMap
    • Hashtable
    • Properties
    • TreeMap
  • Set
    • 相关接口
      • Set
    • HashSet
    • LinkedHashSet
    • TreeSet
  • 其它
    • Iterator和ListIterator区别
      • ListIterator
    • 快速失败(fail-fast)和安全失败(fail-safe)的区别
    • map空值问题
    • ArrayList的subList不可强转成ArrayList
    • 比较器的使用
    • Collections同步方法
    • Arrays.asList() 数组转集合
    • list 转数组

java集合框架^[1]

目录图

框架图

List

相关接口

接口中出现的方法其实现类中必然都有且含义相同，所以先介绍接口，再看具体实现类实现的接口与相关方法

List extends Collection接口

方法较多，请自行参考API

• ListIterator listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
• ListIterator listIterator(int index) 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
• Iterator iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。

Queue接口（队列）

• boolean add(E e)
  将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
• E element()
  获取，但是不移除此队列的头。
• boolean offer(E e)
  将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
• E peek()
  获取但不移除此队列的头；如果此队列为空，则返回 null。
• E poll()
  获取并移除此队列的头，如果此队列为空，则返回 null。
• E remove()
  获取并移除此队列的头。

Deque extends Queue 接口（双端队列）

Queue 方法	等效 Deque 方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

堆栈方法	等效 Deque 方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

ArrayList

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
List list = Collections.synchronizedList(new ArrayList(...)); 

LinkedList

实现的接口：

Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

• Iterator descendingIterator() 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

Vector

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess 

同步的

• Vector() 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。

• Vector(int initialCapacity) 使用指定的初始容量和等于零的容量增量构造一个空向量。

• Vector(int initialCapacity, int capacityIncrement) 使用指定的初始容量和容量增量构造一个空的向量。

• void trimToSize() 对此向量的容量进行微调，使其等于向量的当前大小。

Stack

extends Vector<E>

Deque 接口及其实现提供了 LIFO 堆栈操作的更完整和更一致的 set，应该优先使用此 set，而非此类。例如：

Deque<Integer> stack = new ArrayDeque<Integer>();

特有方法

• Stack()
• boolean empty() 测试堆栈是否为空
• E peek() 查看堆栈顶部的对象，但不从堆栈中移除它。
• E pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
• E push(E item) 把项压入堆栈顶部。
• int search(Object o)
  返回对象在堆栈中的位置，以 1 为基数。

Map

相关接口

Map<K,V>

• void clear()
  从此映射中移除所有映射关系（可选操作）。
• boolean containsKey(Object key)
  如果此映射包含指定键的映射关系，则返回 true。
• boolean containsValue(Object value)
  如果此映射将一个或多个键映射到指定值，则返回 true。
• Set<Map.Entry<K,V>> entrySet()
  返回此映射中包含的映射关系的 Set 视图。
• boolean equals(Object o)
  比较指定的对象与此映射是否相等。
• V get(Object key)
  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
• int hashCode()
  返回此映射的哈希码值。
• boolean isEmpty()
  如果此映射未包含键-值映射关系，则返回 true。
• Set keySet()
  返回此映射中包含的键的 Set 视图。
• V put(K key, V value)
  将指定的值与此映射中的指定键关联（可选操作）。
• void putAll(Map<? extends K,? extends V> m)
  从指定映射中将所有映射关系复制到此映射中（可选操作）。
• V remove(Object key)
  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
• int size()
  返回此映射中的键-值映射关系数。
• Collection values()
  返回此映射中包含的值的 Collection 视图

HashMap

实现原理是数组+链表

• HashMap()
  构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
• HashMap(int initialCapacity)
  构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
• HashMap(int initialCapacity, float loadFactor)
  构造一个带指定初始容量和加载因子的空 HashMap。
• HashMap(Map<? extends K,? extends V> m)
  构造一个映射关系与指定 Map 相同的新 HashMap。

LinkedHashMap

extends HashMap<K,V>

返回的顺序与插入的顺序相同，你也可以这样使用

void foo(Map m) {
     Map copy = new LinkedHashMap(m);
     ...
 }

同步：

Map m = Collections.synchronizedMap(new LinkedHashMap(...));

Hashtable

extends Dictionary<K,V> implements Map<K,V>

它是同步的

• protected void rehash()
  增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。

Properties

extends Hashtable<Object,Object>

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。它是线程安全的。

常用方法：

• String getProperty(String key)
  用指定的键在此属性列表中搜索属性。

• String getProperty(String key, String defaultValue)
  用指定的键在属性列表中搜索属性。

• void list(PrintStream out)
  将属性列表输出到指定的输出流。

• void list(PrintWriter out)
  将属性列表输出到指定的输出流。

• void load(InputStream inStream)
  从输入流中读取属性列表（键和元素对）。

• void load(Reader reader)
  按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

• void loadFromXML(InputStream in)
  将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。

• Enumeration<?> propertyNames()
  返回属性列表中所有键的枚举，如果在主属性列表中未找到同名的键，则包括默认属性列表中不同的键。

• Object setProperty(String key, String value)
  调用 Hashtable 的方法 put。

• void store(OutputStream out, String comments)
  以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

• void store(Writer writer, String comments)
  以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。

• void storeToXML(OutputStream os, String comment)
  发出一个表示此表中包含的所有属性的 XML 文档。

• void storeToXML(OutputStream os, String comment, String encoding)
  使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。

• Set stringPropertyNames()
  返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

TreeMap

基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。

• TreeMap()
  使用键的自然顺序构造一个新的、空的树映射。
• TreeMap(Comparator<? super K> comparator)
  构造一个新的、空的树映射，该映射根据给定比较器进行排序。
• Map.Entry<K,V> ceilingEntry(K key)
  返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
• Comparator<? super K> comparator()
  返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
• Set<Map.Entry<K,V>> entrySet()
  返回此映射中包含的映射关系的 Set 视图。
• Map.Entry<K,V> firstEntry()
  返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
• Map.Entry<K,V> floorEntry(K key)
  返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null
• Map.Entry<K,V> lastEntry()
  返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null
• V put(K key, V value)
  将指定值与此映射中的指定键进行关联。

Set

相关接口

Set

• boolean add(E e)
  如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
• void clear()
  移除此 set 中的所有元素（可选操作）。
• boolean contains(Object o)
  如果 set 包含指定的元素，则返回 true。
• Iterator iterator()
  返回在此 set 中的元素上进行迭代的迭代器。
• boolean removeAll(Collection<?> c)
  移除 set 中那些包含在指定 collection 中的元素（可选操作）。
• boolean retainAll(Collection<?> c)
  仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
• int size()
  返回 set 中的元素数（其容量）。
• ...

HashSet

extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

• HashSet()
  构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。

LinkedHashSet

extends HashSet<E>implements Set<E>, Cloneable, Serializable

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。

void foo(Set s) {
     Set copy = new LinkedHashSet(s);
     ...
 }

• LinkedHashSet()
  构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set。
• LinkedHashSet(Collection<? extends E> c)
  构造一个与指定 collection 中的元素相同的新链接哈希 set。
• LinkedHashSet(int initialCapacity)
  构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。
• LinkedHashSet(int initialCapacity, float loadFactor)
  构造一个带有指定初始容量和加载因子的新空链接哈希 set。

TreeSet

extends AbstractSet<E>implements NavigableSet<E>, Cloneable, Serializable

基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。

常用方法：

• TreeSet()
  构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
• TreeSet(Collection<? extends E> c)
  构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
• TreeSet(Comparator<? super E> comparator)
  构造一个新的空 TreeSet，它根据指定比较器进行排序。
• TreeSet(SortedSet s)
  构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

---

boolean add(E e)
将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。

• E ceiling(E e)
  返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。

• E floor(E e)
  返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。

• E first()
  返回此 set 中当前第一个（最低）元素。

• E last()
  返回此 set 中当前最后一个（最高）元素。

• E lower(E e)
  返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。

• E higher(E e)
  返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null

• E pollFirst()
  获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。

• E pollLast()
  获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

• Iterator descendingIterator()
  返回在此 set 元素上按降序进行迭代的迭代器。

• Iterator iterator()
  返回在此 set 中的元素上按升序进行迭代的迭代器。

其它

Iterator和ListIterator区别

1. ListIterator有add()方法，可以向List中添加对象，而Iterator不能
2. ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
3. ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
4. 都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

ListIterator

• void add(E e)
  将指定的元素插入列表（可选操作）。
• boolean hasNext()
  以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
• boolean hasPrevious()
  如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
• E next()
  返回列表中的下一个元素。
• int nextIndex()
  返回对 next 的后续调用所返回元素的索引。
• E previous()
  返回列表中的前一个元素。
• int previousIndex()
  返回对 previous 的后续调用所返回元素的索引。
• void remove()
  从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
• void set(E e)
  用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

快速失败(fail-fast)和安全失败(fail-safe)的区别

• 快速失败（fail—fast）：
  在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。

  java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）

• 安全失败（fail—safe）:
  采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

  原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。

  缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

  场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

map空值问题

集合类	key	value	Super	说明
Hashtable	not null	not null	Dictionary	线程安全
ConcurrentHashMap	not null	not null	AbstractMap	锁分段技术（JDK8:CAS）
TreeMap	not null	null	AbstractMap	线程不安全
HashMap	null	null	AbstractMap	线程不安全

ArrayList的subList不可强转成ArrayList

ArrayList的subList不可强转成ArrayList,否则会抛出ClassCastException异常。

说明：

subList返回的是ArrayList的内部类SubList，并不是ArrayList而是ArrayList的一个视图，对SubList子列表的所有操作最终都会反映到原列表中

在subList场景中，高度注意对原集合的增加或删除，均会导致子列表的遍历，增加，删除产生的ConcurrentModificationExcetion异常。

比较器的使用

new Comparator<Student>(){
    @Override
    public int compare(Student o1,Student o2){
       if(o1.getScore() > o2.getScore()){
			return 1;
		}else if(o1.getScore() < o2.getScore()){
 			return -1;
 		}else{
 			return 0;
 		}
    }
}

Arrays.class

• static int
  binarySearch(T[] a, T key, Comparator<? super T> c)

      使用二分搜索法来搜索指定数组，以获得指定对象。 
  

• static void
  sort(T[] a, Comparator<? super T> c)

      根据指定比较器产生的顺序对指定对象数组进行排序。 
  

Collections.class

• static int
  binarySearch(List<? extends Comparable<? super T>> list, T key)

      使用二分搜索法搜索指定列表，以获得指定对象。 
  

• static int
  binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

      使用二分搜索法搜索指定列表，以获得指定对象。
  

• static T
  min(Collection<? extends T> coll, Comparator<? super T> comp)

      根据指定比较器产生的顺序，返回给定 collection 的最小元素。 
  

• static T
  max(Collection<? extends T> coll, Comparator<? super T> comp)

      根据指定比较器产生的顺序，返回给定 collection 的最大元素。
  

• static void
  sort(List list, Comparator<? super T> c)

      根据指定比较器产生的顺序对指定列表进行排序。 
  

Collections同步方法

• static Collection
  synchronizedCollection(Collection c)

      返回指定 collection 支持的同步（线程安全的）collection。 
  

• static List
  synchronizedList(List list)

      返回指定列表支持的同步（线程安全的）列表。 
  

• static <K,V> Map<K,V>
  synchronizedMap(Map<K,V> m)

      返回由指定映射支持的同步（线程安全的）映射。 
  

• static Set
  synchronizedSet(Set s)

      返回指定 set 支持的同步（线程安全的）set。 
  

• static <K,V> SortedMap<K,V>
  synchronizedSortedMap(SortedMap<K,V> m)

      返回指定有序映射支持的同步（线程安全的）有序映射。 
  

• static SortedSet
  synchronizedSortedSet(SortedSet s)

      返回指定有序 set 支持的同步（线程安全的）有序 set。 
  

Arrays.asList() 数组转集合

工具类Arrays.asList()把数组转集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法会抛出异常。

说明：

asList的返回对象是一个Arrays内部类，并没有实现集合的修改方法。它体现的是适配器模式，只是转换接口，后台数据仍是数组。

另外数组转集合还可以用这个方法

• static boolean
  addAll(Collection<? super T> c, T... elements)

      将所有指定元素添加到指定 collection 中。 
  

例：

List<String> resultList = new ArrayList<>(array.length);
Collections.addAll(resultList,array);

list 转数组

利用集合的toArray(T[] array)方法

String[] array = new String[list.size()];
array = list.toArray(array);

---

1. 回到目录 ↩︎