Java — 集合、泛型和枚举

已经有数组了，为什么还要使用集合？
Java中数组长度不可变，然而实际情况中数据量往往不确定，这类数据不适合用数组存储，这时候就需要使用集合。

1 Java Collection 接口

表示集合的接口:
接口是集合的抽象数据类型，提供对集合中所表示的内容进行单独操作的可能。

• Collection 接口：该接口是最基本的集合接口，一个 Collection 代表一个元素。
• 线性表List ：该接口实现了 Collection 接口。List 是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。
• Set 接口：该接口也实现了 Collection 接口。它不能包含重复的元素，SortedSet 是按升序排列的 Set 集合。
• Map 接口：包含键值对，Map 不能包含重复的键。SortedMap 是一个按升序排列的 Map 集合。

接口实现类：

• 实现 Set 接口的常用类有 HashSet 和 TreeSet，它们都可以容纳所有类型的对象，但是不能保证序列顺序永久不变。
  HashSet：为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单。
  TreeSet：该类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，该实现类是一个有序的 Set，这样就能从 Set 里面提取一个有序序列。
• 实现 List 接口的常用类有 ArrayList 和 LinkedList，它们也可以容纳所有类型的对象包括 null，并且都保证元素的存储位置。
  ArrayList：一个用数组实现的 List，能进行快速的随机访问，效率高而且实现了可变大小的数组。（Vector也实现了List接口，与ArrayList相比，访问和修改向量的方法为同步方法，其他的两者都相同。如果不需要同步，ArrayList效率更高。）
  LinkedList：对顺序访问进行了优化，但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法，能把它当成栈（Stack）或队列（Queue）来用。
• 实现 Map 映射的类是 HashMap，可实现一个键到值的映射。

Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口，所以也可以调用这些方法。

方法名称	说明
boolean add(E e)	向集合中添加一个元素，E 是元素的数据类型
boolean addAll(Collection c)	向集合中添加集合 c 中的所有元素
void clear()	删除集合中的所有元素
boolean contains(Object o)	判断集合中是否存在指定元素
boolean containsAll(Collection c)	判断集合中是否包含集合 c 中的所有元素
boolean isEmpty()	判断集合是否为空
Iteratoriterator()	返回一个 Iterator 对象，用于遍历集合中的元素
boolean remove(Object o)	从集合中删除一个指定元素
boolean removeAll(Collection c)	从集合中删除所有在集合 c 中出现的元素
boolean retainAll(Collection c)	仅仅保留集合中所有在集合 c 中出现的元素
int size()	返回集合中元素的个数
Object[] toArray()	返回包含此集合中所有元素的数组

2 线性表 — List

常用的线性表List的实现类有两个：数组线性表类（ArrayList）、链表类（LinkedList）。

• ArrayList 类用数组存储元素。若想通过下标随机访问元素，且不会频繁地在线性表的起始位置插入和删除元素，那么ArrayList效率最高。
• LinkedList 类用链表存储元素。若需要在线性表的起始位置上频繁地插入或删除元素，应该使用LinkedList。
  遍历LinkedList不要使用get(i)，太耗时，应使用迭代器。foreach()隐式地实现了迭代器。

注意：ArrayList、LinkedList在中间或末尾位置上插入或删除元素，具有同样的性能。

ArrayList为了进行快速随机访问，专门提供了以下方法：

方法名称	说明
E get(int index)	获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
int index(Object o)	返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
int lastIndexOf(Object o)	返回此集合中最后一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
E set(int index, E element)	将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素
List subList(int fromlndex, int tolndex)	返回一个新的集合，新集合中包含fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的元素

LinkedList为了更好地支持插入删除元素，专门提供了以下方法，可以看出LinkedList特别适合于经常处理首尾元素的场景。

方法名称	说明
void addFirst(E e)	将指定元素添加到此集合的开头
void addLast(E e)	将指定元素添加到此集合的末尾
E getFirst()	返回此集合的第一个元素
E getLast()	返回此集合的最后一个元素
E removeFirst()	删除此集合中的第一个元素
E removeLast()	删除此集合中的最后一个元素

3 Set

• 散列类 HashSet
  HashSet其中的元素是无序的。是按照哈希算法来存储集合中的元素，使用哈希算法可以提高集合元素的存储速度，当向 Set 集合中添加一个元素时，HashSet 会调用该元素的 hashCode() 方法，获取其哈希码，然后根据这个哈希码计算出该元素在集合中的存储位置。
  适用场景：无序列表，底层使用哈希树实现。
• 链式散列集 LinkedHashSet
  LinkedHashSet使用链表实现，其中的元素保持了插入时的顺序。
• 树形集 TreeSet
  类中的元素可以按照自然顺序进行排序。同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。
  适用场景：有序列表，底层使用红黑树实现，通过对红黑树的后推得到顺序集合。
  .
  TreeSet 只能对实现了 Comparable 接口的类对象进行排序，因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。例如 a.compareTo(b)，如果 a 和 b 相等，则该方法返回 0；如果 a 大于 b，则该方法返回大于 0 的值；如果 a 小于 b，则该方法返回小于 0 的值。
  .
  TreeSet为了方便有序数据的场景，专门定义了下面的方法：

方法名称	说明
E first()	返回此集合中的第一个元素。其中，E 表示集合中元素的数据 类型
E last()	返回此集合中的最后一个元素
E poolFirst()	获取并移除此集合中的第一个元素
E poolLast()	获取并移除此集合中的最后一个元素
SortedSet subSet(E fromElement,E toElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement对象之间的所有对象。包含 fromElemen t对象，不包含 toElement 对象
SortedSet headSet<E toElement〉	返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象
SortedSet tailSet(E fromElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象

如何选择HashSet与TreeSet？
需要排序功能时才使用TreeSet，不需要排序时都使用HashSet。

HashSet与TreeSet的底层运行方式:

• TreeSet集合对象的加入过程
    TreeSet的底层是通过二叉树（红黑树）来完成存储的，无序的集合
    当我们将一个对象加入treeset中，treeset会将第一个对象作为根对象，然后调用对象的compareTo方法拿第二个对象和第一个比较，当返回至=0时，说明2个对象内容相等，treeset就不把第二个对象加入集合。返回>1时，说明第二个对象大于第一个对象，将第二个对象放在右边，返回-1时，则将第二个对象放在左边，依次类推

• HashSet集合对象的加入过程
  hashset底层是hash值的地址，它里面存的对象是无序的。
     第一个对象进入集合时，hashset会调用object类的hashcode根据对象在堆内存里的地址调用对象重写的hashcode计算出一个hash值，然后第一个对象就进入hashset集合中的任意一个位置。
    第二个对象开始进入集合，hashset先根据第二个对象在堆内存的地址调用对象的hashcode计算出一个hash值，如果第二个对象和第一个对象在堆内存里的地址是相同的，那么得到的hash值也是相同的，直接返回true，hash得到true后就不把第二个元素加入集合（这段是hash源码程序中的操作）。如果第二个对象和第一个对象在堆内存里地址是不同的，这时hashset类会先调用自己的方法遍历集合中的元素，当遍历到某个元素时，调用对象的equals方法，如果相等，返回true，则说明这两个对象的内容是相同的，hashset得到true后不会把第二个对象加入集合。

最重要：

• TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。
• HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。
• HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的 String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。

参考文献：HashSet与TreeSet 区别

4 映射表 Map

Map 接口常用的实现类有三个：散列映射表HashMap、链式散列映射表LinkedHashMap、树形映射表TreeMap。

• HashMap
  元素无序。
• LinkedHashMap
  元素有两种顺序：插入顺序，访问顺序。
  插入顺序：元素按照插入映射表的顺序排序。使用无参构造方法创建LinkedHashMap对象。
  访问顺序：元素按最后一次被访问的顺序排序。
• TreeMap
  键可以使用Comparable或Comparator接口实现排序。

Map 接口中提供的常用方法如表 1 所示。

方法名称	说明
V get(Object key)	返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value)	向 Map 集合中添加键-值对，返回 key 以前对应的 value，如果没有， 则返回 null
V remove(Object key)	从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如 果没有，则返回null
Set entrySet()	返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据 类型为 Map.Entry
Set keySet()	返回 Map 集合中所有键对象的 Set 集合

HashMap与TreeMap的底层实现与选择方法与HashSet、TreeSet相似。

• 使用HashMap要求添加的键类明确定义了HashCode()和equals()方法（可以重写这两个方法），为了优化HashMap空间的使用，你可以调优初始容量和负载因子。
• TreeMap是SortedMap接口基于红黑树的实现。TreeMap没有调优选项，因为该树总处于平衡状态；
• TreeMap是非线程安全的，可以通过如下方式实现线程安全。
  Map m=Collections.synchronizedSortedMap(new TreeMap())

5 List、Set、Map的线程安全问题

5.1 如何保证线程安全？

1 使用Vector/Stack/HashTable
Hashtable解析：
Hashtable在jdk1.1就有了，那么它是怎样实现线程安全的呢？主要看put、remove、get方法猜它肯定进行的同步控制的。于是看源码：

//put、remove、get都搞成了同步方法，保证了get的安全性
public synchronized V put(K key, V value) {……}
public synchronized V get(Object key) {……}
public synchronized V remove(Object key) {……}

所以为什么Hashtable是线程安全的，因为它的remove,put，get做成了同步方法，保证了Hashtable的线程安全性。

Vector解析
Vector也是用同步方法保证线程安全的。看源码：

 public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }
public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

源码中的modCount是什么？
我们知道 java.util.HashMap 不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出 ConcurrentModificationgException，这就是所谓 fail-fast 策略

fail-fast 机制是java集合（Collection）中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast 事件。

若在多线程环境下使用 fail-fast机制的集合，建议使 “java.util.concurrent 包下的类” 去取代 “java.util 包下的类”。
建议阅读：java.util.Concurrent包下面的常见类

2 将非线程安全的集合转换为线程安全
– 使用Collections.synchronizedXX()方法构建
例如Collections.synchronizedList、Collections.synchronizedMap()、Collections.SynchronizedSortedMap

 //make thread-safe list
  List MyStrList = Collections.synchronizedList(new ArrayList());
  MyStrList.add("123");
  MyStrList.add("abc");
  //make thread-safe hashset
  Set set=Collections.synchronizedSet(new HashSet());
  set.add(123);
  set.add(456);
  //make thread-safe hashmap
  Map map=Collections.synchronizedMap(new HashMap());
  map.put(1, "thb");
  map.put(12, "bill tang");

Collections.synchronizedMap()解析
源码：

        public int size() {
            synchronized (mutex) {return m.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return m.isEmpty();}
        }
        public boolean containsKey(Object key) {
            synchronized (mutex) {return m.containsKey(key);}
        }
        public boolean containsValue(Object value) {
            synchronized (mutex) {return m.containsValue(value);}
        }
        public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }
        public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }

我们惊人的发现，synchronizedMap只是将HashMap的操纵放在了同步代码块中来保证SynchronizedMap的线程安全性。因此，SynchronizedMap也可以允许key和value为null。这样带来的问题也是任何一个时刻只能有一个线程可以操纵synchronizedMap，所以其效率比较低。
—使用ThreadLocal构建