面試半年！三面阿里，四面螞蟻金服，竟然倒在了一個Java集合之Map上？

時間  2020-07-11
標籤 面試 半年 三面 阿里 四面 螞蟻 竟然 倒在 一個 java 集合 map 欄目 快樂工作 简体版
原文   原文鏈接

Map接口

Map與Collection並列存在。用於保存具備映射關係的數據:key-value
Map中的key和value均可以是任何引用類型的數據
Map中的key用set來存放，不容許重複，即同一個Map對象所對應的類，須重寫 hashCode()和 equals()方法
經常使用 String類做爲Map的「鍵」
key和value之間存在單向一對一關係，即經過指定的key總能找到惟一的、肯定的value
Map接口的經常使用實現類:HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是Map接口使用頻率最高的實現類node

1. 常見實現類結構

面試半年！三面阿里，四面螞蟻金服，竟然倒在了一個Java集合之Map上？

|----Map:雙列數據，存儲key-value對的數據   ---相似於高中的函數：y = f(x)
     |----HashMap:做爲Map的主要實現類；線程不安全的，效率高；存儲null的key和value
          |----LinkedHashMap:保證在遍歷map元素時，能夠照添加的順序實現遍歷。
                    緣由：在原的HashMap底層結構基礎上，添加了一對指針，指向前一個和後一個元素。
                    對於頻繁的遍歷操做，此類執行效率高於HashMap。
     |----TreeMap:保證照添加的key-value對進行排序，實現排序遍歷。此時考慮key的天然排序或定製排序
                      底層使用紅黑樹
     |----Hashtable:做爲古老的實現類；線程安全的，效率低；不能存儲null的key和value
          |----Properties:經常使用來處理配置文件。key和value都是String類型

HashMap的底層： 數組+鏈表  （JDK 7.0及以前)
               數組+鏈表+紅黑樹 （JDK 8.0之後)

1.1 HashMap

HashMap是Map接口使用頻率最高的實現類。面試

容許使用null鍵和null值，與 HashSet同樣，不保證映射的順序。算法

全部的key構成的集合是set：無序的、不可重複的。因此，key所在的類要重寫equals()和 hashCode()數組

全部的value構成的集合是Collection：無序的、能夠重複的。因此，value所在的類要重寫:equals()安全

一個key-value構成一個entryide

全部的entry構成的集合是Set：無序的、不可重複的函數

HashMap判斷兩個key相等的標準是：兩個key經過equals()方法返回true，hashCode值也相等。性能

HashMap判斷兩個value相等的標準是：兩個value經過equals()方法返回true.線程

代碼示例：指針

@Test
public void test1(){
    Map map = new HashMap();

    map.put(null,123);

}

1.2 LinkedHashMap

LinkedHashMap底層使用的結構與HashMap相同，由於LinkedHashMap繼承於HashMap.
區別就在於：LinkedHashMap內部提供了Entry，替換HashMap中的Node.
與Linkedhash Set相似，LinkedHashMap能夠維護Map的迭代順序：迭代順序與Key-value對的插入順序一致
代碼示例：

@Test
public void test2(){
    Map map = new LinkedHashMap();
    map.put(123,"AA");
    map.put(345,"BB");
    map.put(12,"CC");

    System.out.println(map);
}

1.3 TreeMap

TreeMap存儲Key-Value對時，須要根據key-value對進行排序。TreeMap能夠保證全部的 Key-Value對處於有序狀態。

TreeSet底層使用紅黑樹結構存儲數據

TreeMap的Key的排序:

天然排序： TreeMap的全部的Key必須實現Comparable接口，並且全部的Key應該是同一個類的對象，不然將會拋出ClasssCastEXception()
定製排序：建立 TreeMap時，傳入一個 Comparator對象，該對象負責對TreeMap中的全部key進行排序。此時不須要Map的Key實現Comparable接口
TreeMap判斷兩個key相等的標準：兩個key經過 compareTo()方法或者compare()方法返回0.

1.4 Hashtable

Hashtable是個古老的Map實現類，JDK1.0就提供了。不一樣於 HashMap，Hashtable是線程安全的.

Hashtable實現原理和HashMap相同，功能相同。底層都使用哈希表結構，查詢速度快，不少狀況下能夠互用

與HashMap.不一樣，Hashtable不容許使用null做爲key和value.

與HashMap同樣，Hashtable也不能保證其中Key-value對的順序.

Hashtable判斷兩個key相等、兩個value相等的標準，與HashMap-致.

1.5 Properties

Properties類是Hashtable的子類，該對象用於處理屬性文件

因爲屬性文件裏的key、value都是字符串類型，因此Properties裏的key和value都是字符串類型

存取數據時，建議使用setProperty(String key,String value)方法和getProperty(String key)方法

代碼示例：

//Properties:經常使用來處理配置文件。key和value都是String類型
public static void main(String[] args)  {
    FileInputStream fis = null;
    try {
        Properties pros = new Properties();

        fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加載流對應的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name = " + name + ", password = " + password);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

2. 存儲結構的理解：

Map中的key:無序的、不可重複的，使用Set存儲所的key ---> key所在的類要重寫equals()和hashCode() （以HashMap爲例)
Map中的value:無序的、可重複的，使用Collection存儲所的value --->value所在的類要重寫equals()
一個鍵值對：key-value構成了一個Entry對象。
Map中的entry:無序的、不可重複的，使用Set存儲所的entry

面試半年！三面阿里，四面螞蟻金服，竟然倒在了一個Java集合之Map上？

3. 經常使用方法

3.1添加、刪除、修改操做：

Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map對象中
void putAll(Map m):將m中的全部key-value對存放到當前map中
Object remove(Object key)：移除指定key的key-value對，並返回value
void clear()：清空當前map中的全部數據
代碼示例：

@Test
public void test1() {
    Map map = new HashMap();
    //Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map對象中
    map.put("AA",123);
    map.put("ZZ",251);
    map.put("CC",110);
    map.put("RR",124);
    map.put("FF",662);
    System.out.println(map);//{AA=123, ZZ=251, CC=110, RR=124, FF=662}

    //Object put(Object key,Object value)：將指定key-value添加到(或修改)當前map對象中
    map.put("ZZ",261);
    System.out.println(map);//{AA=123, ZZ=261, CC=110, RR=124, FF=662}

    //void putAll(Map m):將m中的全部key-value對存放到當前map中
    HashMap map1 = new HashMap();
    map1.put("GG",435);
    map1.put("DD",156);
    map.putAll(map1);
    System.out.println(map);//{AA=123, ZZ=261, CC=110, RR=124, FF=662, GG=435, DD=156}

    //Object remove(Object key)：移除指定key的key-value對，並返回value
    Object value = map.remove("GG");
    System.out.println(value);//435
    System.out.println(map);//{AA=123, ZZ=261, CC=110, RR=124, FF=662, DD=156}

    //void clear()：清空當前map中的全部數據
    map.clear();
    System.out.println(map.size());//0  與map = null操做不一樣
    System.out.println(map);//{}
}

3.2元素查詢的操做：

Object get(Object key)：獲取指定key對應的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value對的個數
boolean isEmpty()：判斷當前map是否爲空
boolean equals(Object obj)：判斷當前map和參數對象obj是否相等
代碼示例：

@Test
public void test2() {
    Map map = new HashMap();
    map.put("AA", 123);
    map.put("ZZ", 251);
    map.put("CC", 110);
    map.put("RR", 124);
    map.put("FF", 662);
    System.out.println(map);//{AA=123, ZZ=251, CC=110, RR=124, FF=662}
    //Object get(Object key)：獲取指定key對應的value
    System.out.println(map.get("AA"));//123

    //boolean containsKey(Object key)：是否包含指定的key
    System.out.println(map.containsKey("ZZ"));//true

    //boolean containsValue(Object value)：是否包含指定的value
    System.out.println(map.containsValue(123));//true

    //int size()：返回map中key-value對的個數
    System.out.println(map.size());//5

    //boolean isEmpty()：判斷當前map是否爲空
    System.out.println(map.isEmpty());//false

    //boolean equals(Object obj)：判斷當前map和參數對象obj是否相等
    Map map1 = new HashMap();
    map1.put("AA", 123);
    map1.put("ZZ", 251);
    map1.put("CC", 110);
    map1.put("RR", 124);
    map1.put("FF", 662);
    System.out.println(map.equals(map1));//true
}

3.3 元視圖操做的方法：

Set keySet()：返回全部key構成的Set集合
Collection values()：返回全部value構成的Collection集合
Set entrySet()：返回全部key-value對構成的Set集合
代碼示例：

@Test
public void test3() {
    Map map = new HashMap();
    map.put("AA", 123);
    map.put("ZZ", 251);
    map.put("CC", 110);
    map.put("RR", 124);
    map.put("FF", 662);
    System.out.println(map);//{AA=123, ZZ=251, CC=110, RR=124, FF=662}
    //遍歷全部的key集:Set keySet()：返回全部key構成的Set集合
    Set set = map.keySet();
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
    System.out.println("--------------");
    //遍歷全部的value集：Collection values()：返回全部value構成的Collection集合
    Collection values = map.values();
    for (Object obj :
         values) {
        System.out.println(obj);
    }
    System.out.println("---------------");
    //Set entrySet()：返回全部key-value對構成的Set集合
    Set entrySet = map.entrySet();
    Iterator iterator1 = entrySet.iterator();
    //方式一：
    while (iterator1.hasNext()) {
        Object obj = iterator1.next();
        //entrySet集合中的元素都是entry
        Map.Entry entry = (Map.Entry) obj;
        System.out.println(entry.getKey() + "-->" + entry.getValue());
    }
    System.out.println("--------------");

    //方式二：
    Set keySet = map.keySet();
    Iterator iterator2 = keySet.iterator();
    while (iterator2.hasNext()) {
        Object key = iterator2.next();
        Object value = map.get(key);
        System.out.println(key + "==" + value);
    }
}

總結：經常使用方法：

添加：put(Object key,Object value)
刪除：remove(Object key)
修改：put(Object key,Object value)
查詢：get(Object key)
長度：size()
遍歷：keySet() / values() / entrySet()

4. 內存結構說明：（難點）

4.1 HashMap在JDK 7.0中實現原理：

4.1.1 HashMap的存儲結構：

JDK 7.0及之前的版本：HashMap是數組+鏈表結構（地址鏈表法）

JDK 8.0版本之後：HashMap是數組+鏈表+紅黑樹實現

面試半年！三面阿里，四面螞蟻金服，竟然倒在了一個Java集合之Map上？

4.1.2 對象建立和添加過程：

HashMap map = new HashMap():

在實例化之後，底層建立了長度是16的一維數組Entry[] table。

​ ...可能已經執行過屢次put...

map.put(key1,value1):

首先，調用key1所在類的hashCode()計算key1哈希值，此哈希值通過某種算法計算之後，獲得在Entry數組中的存放位置。
若是此位置上的數據爲空，此時的key1-value1添加成功。 ----狀況1
若是此位置上的數據不爲空，(意味着此位置上存在一個或多個數據(以鏈表形式存在)),比較key1和已經存在的一個或多個數據的哈希值：
若是key1的哈希值與已經存在的數據的哈希值都不相同，此時key1-value1添加成功。----狀況2
若是key1的哈希值和已經存在的某一個數據(key2-value2)的哈希值相同，繼續比較：調用key1所在類的equals(key2)方法，比較：
若是equals()返回false:此時key1-value1添加成功。----狀況3
若是equals()返回true:使用value1替換value2。

補充：關於狀況2和狀況3：此時key1-value1和原來的數據以鏈表的方式存儲。

在不斷的添加過程當中，會涉及到擴容問題，當超出臨界值(且要存放的位置非空)時，擴容。默認的擴容方式：擴容爲原來容量的2倍，並將原有的數據複製過來。

4.1.3 HashMap的擴容

當HashMap中的元素愈來愈多的時候，hash衝突的概率也就愈來愈高，由於數組的長度是固定的。因此爲了提升查詢的效率，就要對 HashMap的數組進行擴容，而在HashMap數組擴容以後，原數組中的數據必須從新計算其在新數組中的位置，並放進去，這就是 resize。

4.1.4 HashMap擴容時機

當HashMap中的元素個數超過數組大小（數組總大小 length，不是數組中個數） loadFactor時，就會進行數組擴容，loadFactor的默認值(DEFAULTLOAD FACTOR)爲0.75，這是一個折中的取值。也就是說，默認狀況下，數組大小(DEFAULT INITIAL CAPACITY)爲16，那麼當 HashMap中元素個數超過16 0.75=12（這個值就是代碼中的 threshold值，也叫作臨界值）的時候，就把數組的大小擴展爲2 * 16=32，即擴大一倍，而後從新計算每一個元素在數組中的位置，而這是一個很是消耗性能的操做，因此若是咱們已經預知 HashMap中元素的個數，那麼預設元素的個數可以有效的提升HashMap的性能。

4.2 HashMap在JDK 8.0底層實現原理：

4.2.1 HashMap的存儲結構：

HashMap的內部存儲結構實際上是數組+鏈表+紅黑樹的組合。

4.2.2 HashMap添加元素的過程：

當實例化一個HashMap時，會初始化 initialCapacity和loadFactor，在put第一對映射關係時，系統會建立一個長度爲 initialCapacity的Node數組，這個長度在哈希表中被稱爲容量（Capacity），在這個數組中能夠存放元素的位置咱們稱之爲「桶」（ bucket），每一個bucket都有本身的索引，系統能夠根據索引快速的查找bucket中的元素。

每一個 bucket中存儲一個元素，即一個Node對象，但每個Noe對象能夠帶個引用變量next，用於指向下一個元素，所以，在一個桶中，就有可能生成一個Node鏈。也多是一個一個 TreeNode對象，每個Tree node對象能夠有兩個葉子結點left和right，所以，在一個桶中，就有可能生成一個TreeNode樹。而新添加的元素做爲鏈表的last，或樹的葉子結點。

4.2.3 HashMap的擴容機制:

當HashMapl中的其中一個鏈的對象個數沒有達到8個和JDK 7.0之前的擴容方式同樣。
當HashMapl中的其中一個鏈的對象個數若是達到了8個，此時若是 capacity沒有達到64，那麼HashMap會先擴容解決，若是已經達到了64，那麼這個鏈會變成樹，結點類型由Node變成 Tree Node類型。固然，若是當映射關係被移除後，下次resize方法時判斷樹的結點個數低於6個，也會把樹再轉爲鏈表。

4.2.4 JDK 8.0與JDK 7.0中HashMap底層的變化：

new HashMap():底層沒有建立一個長度爲16的數組

JDK 8.0底層的數組是：Node[],而非Entry[]

首次調用put()方法時，底層建立長度爲16的數組

JDK 7.0底層結構只有：數組+鏈表。JDK 8.0中底層結構：數組+鏈表+紅黑樹。

造成鏈表時，七上八下（jdk7:新的元素指向舊的元素。jdk8：舊的元素指向新的元素）
當數組的某一個索引位置上的元素以鏈表形式存在的數據個數 > 8 且當前數組的長度 > 64時，此時此索引位置上的所數據改成使用紅黑樹存儲。

4.3 HashMap底層典型屬性的屬性的說明：

DEFAULT_INITIAL_CAPACITY : HashMap的默認容量，16
DEFAULT_LOAD_FACTOR：HashMap的默認加載因子：0.75
threshold：擴容的臨界值，= 容量填充因子：16 0.75 => 12
TREEIFY_THRESHOLD：Bucket中鏈表長度大於該默認值，轉化爲紅黑樹:JDK 8.0引入
MIN_TREEIFY_CAPACITY：桶中的Node被樹化時最小的hash表容量:64

4.4 LinkedHashMap的底層實現原理

LinkedHashMap底層使用的結構與HashMap相同，由於LinkedHashMap繼承於HashMap.
區別就在於：LinkedHashMap內部提供了Entry，替換HashMap中的Node.
與Linkedhash Set相似，LinkedHashMap能夠維護Map的迭代順序：迭代順序與Key-value對的插入順序一致
HashMap中內部類Node源碼：

static class Node<K,V> implements Map.Entry<K,V>{
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

LinkedHashM中內部類Entry源碼：

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;//可以記錄添加的元素的前後順序
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

5. TreeMap的使用

向TreeMap中添加key-value，要求key必須是由同一個類建立的對象 要照key進行排序：天然排序 、定製排序

代碼示例：

//天然排序
@Test
public void test() {
    TreeMap map = new TreeMap();
    User u1 = new User("Tom", 23);
    User u2 = new User("Jarry", 18);
    User u3 = new User("Bruce", 56);
    User u4 = new User("Davie", 23);

    map.put(u1, 98);
    map.put(u2, 16);
    map.put(u3, 92);
    map.put(u4, 100);

    Set entrySet = map.entrySet();
    Iterator iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Object obj = iterator.next();
        Map.Entry entry = (Map.Entry) obj;
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
}

//定製排序：按照年齡大小排
@Test
public void test2() {
    TreeMap map = new TreeMap(new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof User && o2 instanceof User) {
                User u1 = (User) o1;
                User u2 = (User) o2;
                return Integer.compare(u1.getAge(), u2.getAge());
            }
            throw new RuntimeException("輸入數據類型錯誤");
        }
    });
    User u1 = new User("Tom", 23);
    User u2 = new User("Jarry", 18);
    User u3 = new User("Bruce", 56);
    User u4 = new User("Davie", 23);

    map.put(u1, 98);
    map.put(u2, 16);
    map.put(u3, 92);
    map.put(u4, 100);

    Set entrySet = map.entrySet();
    Iterator iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Object obj = iterator.next();
        Map.Entry entry = (Map.Entry) obj;
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
}

6.使用Properties讀取配置文件

代碼示例：

//Properties:經常使用來處理配置文件。key和value都是String類型
public static void main(String[] args)  {
    FileInputStream fis = null;
    try {
        Properties pros = new Properties();

        fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加載流對應的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name = " + name + ", password = " + password);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

最後

你們看完有什麼不懂的話能夠在下方留言評論，也能夠私信問我，我通常看到以後都會回覆的。也歡迎你們關注個人公衆號：前程有光，立刻金九銀十跳槽面試季，整理了1000多道將近500多頁pdf文檔的Java面試題資料，文章都會在裏面更新，整理的資料也會放在裏面。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程