ArrayList、LinkedList、Vector、 hashMap、hashtable、ConcurrentHashMap的原理以及区别

 

ArrayList、LinkedList、Vector区别和实现原理。

ArrayList、LinkedList、Vector是集合中经常拿来比较和面试的一个问题，我这里简要概括一下他们的区别和实现原理。这里需要区别jdk1.6和jdk1.8。我们从三个方面去阐述：

存储结构

        ArrayList和Vector是按照顺序将元素存储（从下标为0开始），删除元素时，删除操作完成后，需要使部分元素移位，默认的初始容量都是10（但jdk1.6确实初始容量为10），但jdk1.8，如果只是初始化无参构造函数时，初始容量为0，当第一次添加add()时，会扩容到10。

      1.当创建方式为 List list = new ArrayList(0)时，默认调用EMPTY_ELEMENTDATA初始化容量为0，当首次添加元素时，容量扩为 1；

ArrayList源码：

//被用于空实例的共享空数组实例
 private static final Object[] EMPTY_ELEMENTDATA = {};

//当创建为ArrayList(0)，默认调用EMPTY_ELEMENTDATA初始化容量为0
 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
//首次添加add()数据时，扩容变为1；
 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

     2.当创建方式为 List list = new ArrayList()时，默认调用DEFAULTCAPACITY_EMPTY_ELEMENTDATA 初始化容量为0，当首次添加元素时，容量扩为 10；

//默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

 
//被用于默认大小的空实例的共享数组实例。其与EMPTY_ELEMENTDATA的区别是：当我们向数组中添加第一个元素时，知道数组该扩充多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//创建ArrayList()时，即无参构造方法时：默认调用DEFAULTCAPACITY_EMPTY_ELEMENTDATA初始化容量为0
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

//执行添加add()数据之后，查询集合的size是否为0
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
//如果size不为0，调用calculateCapacity()方法
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }



//首次添加add()数据时扩容为10
private static int calculateCapacity (Object[] elementData, int minCapacity) {  
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  
        return Math.max(DEFAULT_CAPACITY, minCapacity);  
    }  
    return minCapacity;  
    }  

ArrayList和Vector是基于动态数组实现的，LinkedList是基于双向链表实现的（含有头结点）。

 

线程安全性

ArrayList不具有有线程安全性，在单线程的环境中，LinkedList也是线程不安全的，如果在并发环境下使用它们，可以用Collections类中的静态方法synchronizedList(）对ArrayList和LinkedList进行调用即可，即可达到线程安全问题。

//调用Collections的静态方法，即可达到线程安全
 public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

Vector实现线程安全的，即他的方法大都包含关键字synchronized,但是Vector的效率没有ArraykList和LinkedList高。

//大部分方法被synchronized修饰
 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

扩容机制

       从内部实现机制来讲，ArrayList和Vector都是使用Object的数组形式来存储的，当向这两种类型中增加元素的时候，若容量不够，需要进行扩容。ArrayList扩容后的容量是之前的1.5倍，然后把之前的数据拷贝到新建的数组中去。而Vector默认情况下扩容后的容量是之前的2倍。

Vector可以设置容量增量，而ArrayList不可以。在Vector中，有capacityIncrement：当大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小，则Vector中动态数组容量需要增加时，如果容量的增量大于0，则增加的是大小是capacityIncrement，如果增量小于0，则增大为之前的2倍。

在这里需要说一下可变长度数组的原理：当元素个数超过数组的长度时，会产生一个新的数组，将原数组的数据复制到新数组，再将新的元素添加到新数组中。

 

增删改查的效率

           ArrayList和Vector中，从指定的位置检索一个对象，或在集合的末尾插入，删除一个元素的时间是一样的，时间复杂度都是O（1）。但是如果在其他位置增加或者删除元素花费的时间是O（n）,LinkedList中，在插入、删除任何位置的元素所花费的时间都是一样的，时间复杂度都为O（1），但是他在检索一个元素的时间复杂度为O（n）。所以如果只是查找特定位置的元素或只在集合的末端增加移动元素，那么使用ArrayList或Vector都是一样的。如果是在指定位置的插入、删除元素，最好选择LinkedList。

        总结：ArrayList：动态数组结构，线程非安全，查询速度较快，

                   LinkedList：双向链表结构，线程非安全，增删比较块，

                   Vector ：动态数组结构，线程安全。

        java中数据存储方式最底层的两种结构，一种是数组，另一种就是链表，数组的特点：连续空间，寻址迅速，但是在删除或者添加元素的时候需要有较大幅度的移动，所以查询速度快，增删较慢。而链表正好相反，由于空间不连续，寻址困难，增删元素只需修改指针，所以查询慢、增删快。有没有两者的结合呢？有，哈希表具有较快（常量级）的查询速度，及相对较快的增删速度。

 

 

--------------------------------------以下内容部分摘抄于这位大神的博客------------------------------------

https://blog.csdn.net/zhangerqing/article/details/8193118

https://www.cnblogs.com/heyonggang/p/9112731.html

hashMap hashtable ConcurrentHashMap区别

HashMap

1.从类定义上：HashMap 继承自 AbstractMap

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable{};

2.hashMap内部存储结构：

    数组加链表结构：

从上图中，我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。它的内部其实是用一个Entity数组来实现的，属性有key、value、next。接下来我会从初始化阶段详细的讲解HashMap的内部结构。                                    

3.初始容量以及扩容：

       初始化容量为16，扩容：newsize = oldsize*2，size一定为2的n次幂，底层调用resize（）方法进行扩容。                          扩容机制：当Map中元素总数超过Entry数组的75%，触发扩容机制；但，插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

 4.线程是否安全：

    没有被synchronized修饰，线程非安全；

 public boolean isEmpty() { }
 public V get(Object key) { }
 public boolean containsKey(Object key) { }
 public V put(K key, V value){ }
 ......

     5.hashMap允许键值为空：而在 HashMap 的 put 方法中，调用了 putVal （）方法，该方法需要有一个 int 类型的 hash 值，这个值是利用内部的 hash 方法产生的。从下面的源代码可以看出，当 key 为 null 时，返回的 hash 值为 0，说明在 HashMap 中是允许 key=null 的情况存在的。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict){
}
    
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

6.HashMap的初始值还要考虑加载因子:                                                                                                                                            1）哈希冲突：就是在Entry数组中的位置若干Key的哈希值按数组大小取模后，如果落在同一个数组下标上，将组成一条Entry链，对Key的查找需要遍历Entry链上的每个元素执行equals()比较。                                                                                           

2）加载因子：为了降低哈希冲突的概率，默认当HashMap中的键值对达到数组大小的75%时，即会触发扩容。因此，如果预估容量是100，即需要设定100/0.75＝134的数组大小。                                                                                                                        3）空间换时间：如果希望加快Key查找的时间，还可以进一步降低加载因子，加大初始大小，以降低哈希冲突的概率

Hashtable

1.从类定义上：

  Hashtable继承Dictionary；

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {};

2.存储结构上：数组加链表结构，和hashMap基本相同

3.初始容量以及扩容：

       初始size为11，扩容：newsize = olesize*2+1，通过rehash（）方法进行扩容，

       计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

4.线程是否安全：

Hashtable 在很多方法定义时都会加上 synchronized关键字，说明 Hashtable 是线程安全的

  public synchronized int size() {   return count; }
  public synchronized boolean isEmpty() {  return count == 0;}
  public synchronized V get(Object key){}
  public synchronized boolean contains(Object value) {}
  ......

5.是否允许键值为空:

在 Hashtable 添加元素源码中，我们可以发现，如果添加元素的 value 为 null 时，会抛出 NullPointerException。在程序内部，有这样一行代码 int hash = key.hashCode ，如果添加的 key 为 null 时，此时也会抛出空指针异常，因此，在 Hashtable 中，是不允许 key 和 value 为 null 的

  public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

ConcurrentHashMap

1.底层采用分段的数组+链表实现，底层先调用lock()，lock是ReentrantLock类的一个方法，因此是线程安全

2.通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)

3.Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术，分段加锁。

4.有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁

5.扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

注：

ConcurrentHashMap是使用了锁分段技术来保证线程安全的。

锁分段技术：首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。 

ConcurrentHashMap提供了与Hashtable和SynchronizedMap不同的锁机制。Hashtable中采用的锁机制是一次锁住整个hash表，从而在同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。

ConcurrentHashMap默认将hash表分为16个桶，诸如get、put、remove等常用操作只锁住当前需要用到的桶。这样，原来只能一个线程进入，现在却能同时有16个写线程执行，并发性能的提升是显而易见的。