java面試題-Java集合相關

1. ArrayList 和 Vector 的區別

　　ArrayList和Vector底層實現原理都是同樣得,都是使用數組方式存儲數據

　　Vector是線程安全的，可是性能比ArrayList要低。

　　ArrayList，Vector主要區別爲如下幾點：

　　 （1）：Vector是線程安全的，源碼中有不少的synchronized能夠看出，而ArrayList不是。致使Vector效率沒法和ArrayList相比；

 　    （2）：ArrayList和Vector都採用線性連續存儲空間，當存儲空間不足的時候，ArrayList默認增長爲原來的50%，Vector默認增長爲原來的一倍；

　　 （3）：Vector能夠設置capacityIncrement，而ArrayList不能夠，從字面理解就是capacity容量，Increment增長，容量增加的參數。

 

2.說說 ArrayList,Vector, LinkedList 的存儲性能和特性

　　ArrayList採用的數組形式來保存對象，這種方法將對象放在連續的位置中，因此最大的缺點就是插入和刪除的時候比較麻煩，查找比較快；

　　Vector使用了sychronized方法(線程安全),因此在性能上比ArrayList要差些.

　　LinkedList採用的鏈表將對象存放在獨立的空間中，並且在每一個空間中還保存下一個鏈表的索引。使用雙向鏈表方式存儲數據,按序號索引數據須要前向或後向遍歷數據，因此索引數據慢,是插入數據時只須要記錄先後項便可,因此插入的速度快。

 

3.快速失敗 (fail-fast) 和安全失敗 (fail-safe) 的區別是什麼？

　　1.快速失敗

　　原理是：

        迭代器在遍歷時直接訪問集合中的內容，而且在遍歷過程當中使用一個modCount變量。集合在被遍歷期間若是內容發生變化，就會改變modCount的值。每當迭代器使用hasNext（）或next（）遍歷下一個元素以前，都會先檢查modCount變量是否爲expectmodCount值。若是是的話就返回遍歷；不然拋出異常，終止遍歷。

　　查看ArrayList源碼，在next方法執行的時候，會執行checkForComodification()方法。

       

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

　　這裏異常的拋出條件是modCount != expectedModCount這個條件。若是集合發生變化時修改modCount值恰好又設置爲了expectedModCount值，則異常不會拋出。所以，不能依賴於這個異常是否拋出而進行併發操做，這個異常只建議用於檢測併發修改的bug。

　　2.安全失敗

　　　　採用安全失敗機制的集合容器，在遍歷時不是直接在集合上訪問的，而是先複製原有集合內容，在拷貝的集合上進行遍歷。

　　原理：

        　　因爲迭代時是對原集合的拷貝進行遍歷，因此在遍歷過程當中對原集合所作的修改並不能被迭代器檢測到，因此不會觸發ConcurrentModificationException，例如CopyOnWriteArrayList。

　　缺點：

        　　基於拷貝內容的優勢是避免了ConcurrentModificationException，但一樣地，迭代器並不能訪問到修改後的內容。即：迭代器遍歷的是開始遍歷那一刻拿到的集合拷貝，在遍歷期間原集合發生的修改迭代器是不知道的。

　　場景：

        　　Java.util.concurrent包下的容器都是安全失敗的，能夠在多線程下併發使用，併發修改。

        快速失敗和安全失敗都是對迭代器而言的。快速失敗：當在迭代一個集合時，若是有另一個線程在修改這個集合，就會跑出ConcurrentModificationException，java.util下都是快速失敗。安全失敗：在迭代時候會在集合二層作一個拷貝，因此在修改集合上層元素不會影響下層。在java.util.concurrent包下都是安全失敗。

 

4.HashMap 的數據結構

　　HashMap的主幹類是一個Entry數組(jdk1.7) ,每一個Entry都包含有一個鍵值隊(key-value).

　　咱們能夠看一下源碼:

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存儲指向下一個Entry的引用，單鏈表結構
        int hash;//對key的hashcode值進行hash運算後獲得的值，存儲在Entry，避免重複計算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

　　因此,HashMap的總體結果以下

　　

 

 　　簡單來講，HashMap由數組+鏈表組成的，數組是HashMap的主體，鏈表則是主要爲了解決哈希衝突而存在的，若是定位到的數組位置不含鏈表（當前entry的next指向null）,那麼對於查找，添加等操做很快，僅需一次尋址便可；若是定位到的數組包含鏈表，對於添加操做，其時間複雜度爲O(n)，首先遍歷鏈表，存在即覆蓋，不然新增；對於查找操做來說，仍需遍歷鏈表，而後經過key對象的equals方法逐一比對查找。因此，性能考慮，HashMap中的鏈表出現越少，性能纔會越好。

 

5.HashMap 的工做原理

　　HashMap基於hashing原理，咱們經過put()和get()方法存儲和獲取對象，當咱們將鍵值對傳遞給put()方法時，它調用鍵對象的hashCode()方法來計算hashcode,讓後找到bucket位置來存儲值對象。當獲取對象時，經過鍵對象的equals()方法找到正確的鍵值對，而後返回對象。

　　咱們看一下put()源碼：

public V put(K key, V value) {
        //當key爲null，調用putForNullKey方法，保存null與table第一個位置中，這是HashMap容許爲null的緣由
        if (key == null)
            return putForNullKey(value);
        //計算key的hash值
        int hash = hash(key.hashCode());                  //計算key hash 值在 table 數組中的位置
        int i = indexFor(hash, table.length);             //從i出開始迭代 e,找到 key 保存的位置
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判斷該條鏈上是否有hash值相同的(key相同)
            //若存在相同，則直接覆蓋value，返回舊value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;    //舊值 = 新值
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //返回舊值
            }
        }
        //修改次數增長1
        modCount++;
        //將key、value添加至i位置處
        addEntry(hash, key, value, i);
        return null;
    }

　　經過源碼咱們能夠清晰看到HashMap保存數據的過程爲：首先判斷key是否爲null，若爲null，則直接調用putForNullKey方法。若不爲空則先計算key的hash值，而後根據hash值搜索在table數組中的索引位置，若是table數組在該位置處有元素，則經過比較是否存在相同的key，若存在則覆蓋原來key的value，不然將該元素保存在鏈頭（最早保存的元素放在鏈尾）。若table在該處沒有元素，則直接保存。

　　get()源碼:　

public V get(Object key) {
        // 若爲null，調用getForNullKey方法返回相對應的value
        if (key == null)
            return getForNullKey();
        // 根據該 key 的 hashCode 值計算它的 hash 碼  
        int hash = hash(key.hashCode());
        // 取出 table 數組中指定索引處的值
        for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
            Object k;
            //若搜索的key與查找的key相同，則返回相對應的value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

　　在這裏可以根據key快速的取到value除了和HashMap的數據結構密不可分外，還和Entry有莫大的關係，在前面就提到過，HashMap在存儲過程當中並無將key，value分開來存儲，而是當作一個總體key-value來處理的，這個總體就是Entry對象。同時value也只至關於key的附屬而已。在存儲的過程當中，系統根據key的hashcode來決定Entry在table數組中的存儲位置，在取的過程當中一樣根據key的hashcode取出相對應的Entry對象。

 

6.Hashmap 何時進行擴容呢？

　　這裏咱們再來複習put的流程：當咱們想一個HashMap中添加一對key-value時，系統首先會計算key的hash值，而後根據hash值確認在table中存儲的位置。若該位置沒有元素，則直接插入。不然迭代該處元素鏈表並依此比較其key的hash值。若是兩個hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),則用新的Entry的value覆蓋原來節點的value。若是兩個hash值相等但key值不等 ，則將該節點插入該鏈表的鏈頭。具體的實現過程見addEntry方法，以下：

void addEntry(int hash, K key, V value, int bucketIndex) {
        //獲取bucketIndex處的Entry
        Entry<K, V> e = table[bucketIndex];
        //將新建立的 Entry 放入 bucketIndex 索引處，並讓新的 Entry 指向原來的 Entry 
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
        //若HashMap中元素的個數超過極限了，則容量擴大兩倍
        if (size++ >= threshold)
            resize(2 * table.length);
    }

　　這個方法中有兩點須要注意：

      一是鏈的產生。這是一個很是優雅的設計。系統老是將新的Entry對象添加到bucketIndex處。若是bucketIndex處已經有了對象，那麼新添加的Entry對象將指向原有的Entry對象，造成一條Entry鏈，可是若bucketIndex處沒有Entry對象，也就是e==null,那麼新添加的Entry對象指向null，也就不會產生Entry鏈了。

      2、擴容問題。

      隨着HashMap中元素的數量愈來愈多，發生碰撞的機率就愈來愈大，所產生的鏈表長度就會愈來愈長，這樣勢必會影響HashMap的速度，爲了保證HashMap的效率，系統必需要在某個臨界點進行擴容處理。該臨界點在當HashMap中元素的數量等於table數組長度*加載因子。可是擴容是一個很是耗時的過程，由於它須要從新計算這些數據在新table數組中的位置並進行復制處理。因此若是咱們已經預知HashMap中元素的個數，那麼預設元素的個數可以有效的提升HashMap的性能。

 

 7.HashSet怎樣保證元素不重複

　　都知道HashSet中不能存放重複的元素,有時候能夠用來作去重操做。可是其內部是怎麼保證元素不重複的呢？

　　打開HashSet源碼，發現其內部維護一個HashMap:

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

    private static final Object PRESENT = new Object();

 
    public HashSet() {
        map = new HashMap<>();
    }
　　...
}

　　HashSet的構造方法其實就是在內部實例化了一個HashMap對象，其中還會看到一個static final的PRESENT變量；

　　想知道爲何HashSet不能存放重複對象，那麼第一步看看它的add方法進行的判重，代碼以下

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

　　其實看add()方法，這時候答案已經出來了：HashMap的key是不能重複的，而這裏HashSet的元素又是做爲了map的key，固然也不能重複了。

　　順便看一下HashMap裏面又是怎麼保證key不重複的，代碼以下：

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

　　其中最關鍵的一句：　

if (e.hash == hash && ((k = e.key) == key || key.equals(k))) 

　　調用了對象的hashCode和equals方法進行判斷，因此又獲得一個結論：若要將對象存放到HashSet中並保證對象不重複，應根據實際狀況將對象的hashCode方法和equals方法進行重寫