BAT面試必問HashMap原始碼分析

HashMap 簡介

HashMap 主要用來存放鍵值對，它基於雜湊表的Map介面實現，是常用的Java集合之一。

JDK1.8 之前 HashMap 由陣列+連結串列組成的，陣列是 HashMap 的主體，連結串列則是主要為了解決雜湊衝突而存在的（“拉鍊法”解決衝突）.JDK1.8 以後在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為 8）時，將連結串列轉化為紅黑樹，以減少搜尋時間。

底層資料結構分析

JDK1.8之前

JDK1.8 之前 HashMap 底層是 陣列和連結串列 結合在一起使用也就是 連結串列雜湊。HashMap 通過 key 的 hashCode 經過擾動函式處理過後得到 hash 值，然後通過 (n - 1) & hash

判斷當前元素存放的位置（這裡的 n 指的是陣列的長度），如果當前位置存在元素的話，就判斷該元素與要存入的元素的 hash 值以及 key 是否相同，如果相同的話，直接覆蓋，不相同就通過拉鍊法解決衝突。

所謂擾動函式指的就是 HashMap 的 hash 方法。使用 hash 方法也就是擾動函式是為了防止一些實現比較差的 hashCode() 方法換句話說使用擾動函式之後可以減少碰撞。

JDK 1.8 HashMap 的 hash 方法原始碼:

JDK 1.8 的 hash方法相比於 JDK 1.7 hash 方法更加簡化，但是原理不變。

static final int hash(Object key) {

int h;

// key.hashCode()：返回雜湊值也就是hashcode

// ^ ：按位異或

// >>>:無符號右移，忽略符號位，空位都以0補齊

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

對比一下 JDK1.7的 HashMap 的 hash 方法原始碼.

static int hash(int h) {

// This function ensures that hashCodes that differ only by

// constant multiples at each bit position have a bounded

// number of collisions (approximately 8 at default load factor).

h ^= (h >>> 20) ^ (h >>> 12);

return h ^ (h >>> 7) ^ (h >>> 4);

}

相比於 JDK1.8 的 hash 方法，JDK 1.7 的 hash 方法的效能會稍差一點點，因為畢竟擾動了 4 次。

所謂 “拉鍊法” 就是：將連結串列和陣列相結合。也就是說建立一個連結串列陣列，陣列中每一格就是一個連結串列。若遇到雜湊衝突，則將衝突的值加到連結串列中即可。

JDK1.8之後

相比於之前的版本，jdk1.8在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間。

類的屬性：

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

// 序列號

private static final long serialVersionUID = 362498820763181265L;

// 預設的初始容量是16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

// 最大容量

static final int MAXIMUM_CAPACITY = 1 << 30;

// 預設的填充因子

static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹

static final int TREEIFY_THRESHOLD = 8;

// 當桶(bucket)上的結點數小於這個值時樹轉連結串列

static final int UNTREEIFY_THRESHOLD = 6;

// 桶中結構轉化為紅黑樹對應的table的最小大小

static final int MIN_TREEIFY_CAPACITY = 64;

// 儲存元素的陣列，總是2的冪次倍

transient Node<k,v>[] table;

// 存放具體元素的集

transient Set<map.entry<k,v>> entrySet;

// 存放元素的個數，注意這個不等於陣列的長度。

transient int size;

// 每次擴容和更改map結構的計數器

transient int modCount;

// 臨界值當實際大小(容量*填充因子)超過臨界值時，會進行擴容

int threshold;

// 填充因子

final float loadFactor;

}

loadFactor載入因子

loadFactor載入因子是控制陣列存放資料的疏密程度，loadFactor越趨近於1，那麼陣列中存放的資料(entry)也就越多，也就越密，也就是會讓連結串列的長度增加，load Factor越小，也就是趨近於0，

loadFactor太大導致查詢元素效率低，太小導致陣列的利用率低，存放的資料會很分散。loadFactor的預設值為0.75f是官方給出的一個比較好的臨界值。

threshold

threshold = capacity * loadFactor，當Size>=threshold的時候，那麼就要考慮對陣列的擴增了，也就是說，這個的意思就是衡量陣列是否需要擴增的一個標準。

Node節點類原始碼：

// 繼承自 Map.Entry<K,V>

static class Node<K,V> implements Map.Entry<K,V> {

final int hash;// 雜湊值，存放元素到hashmap中時用來與其他元素hash值比較

final K key;//鍵

V value;//值

// 指向下一個節點

Node<K,V> next;

Node(int hash, K key, V value, Node<K,V> next) {

this.hash = hash;

this.key = key;

this.value = value;

this.next = next;

}

public final K getKey() { return key; }

public final V getValue() { return value; }

public final String toString() { return key + "=" + value; }

// 重寫hashCode()方法

public final int hashCode() {

return Objects.hashCode(key) ^ Objects.hashCode(value);

}

public final V setValue(V newValue) {

V oldValue = value;

value = newValue;

return oldValue;

}

// 重寫 equals() 方法

public final boolean equals(Object o) {

if (o == this)

return true;

if (o instanceof Map.Entry) {

Map.Entry<?,?> e = (Map.Entry<?,?>)o;

if (Objects.equals(key, e.getKey()) &&

Objects.equals(value, e.getValue()))

return true;

}

return false;

}

樹節點類原始碼：

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {

TreeNode<K,V> parent; // 父

TreeNode<K,V> left; // 左

TreeNode<K,V> right; // 右

TreeNode<K,V> prev; // needed to unlink next upon deletion

boolean red; // 判斷顏色

TreeNode(int hash, K key, V val, Node<K,V> next) {

super(hash, key, val, next);

}

// 返回根節點

final TreeNode<K,V> root() {

for (TreeNode<K,V> r = this, p;;) {

if ((p = r.parent) == null)

return r;

r = p;

}

HashMap原始碼分析

構造方法

// 預設建構函式。

public More ...HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

// 包含另一個“Map”的建構函式

public More ...HashMap(Map<? extends K, ? extends V> m) {

this.loadFactor = DEFAULT_LOAD_FACTOR;

putMapEntries(m, false);//下面會分析到這個方法

}

// 指定“容量大小”的建構函式

public More ...HashMap(int initialCapacity) {

this(initialCapacity, DEFAULT_LOAD_FACTOR);

}

// 指定“容量大小”和“載入因子”的建構函式

public More ...HashMap(int initialCapacity, float loadFactor) {

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

this.loadFactor = loadFactor;

this.threshold = tableSizeFor(initialCapacity);

}

putMapEntries方法：

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {

int s = m.size();

if (s > 0) {

// 判斷table是否已經初始化

if (table == null) { // pre-size

// 未初始化，s為m的實際元素個數

float ft = ((float)s / loadFactor) + 1.0F;

int t = ((ft < (float)MAXIMUM_CAPACITY) ?

(int)ft : MAXIMUM_CAPACITY);

// 計算得到的t大於閾值，則初始化閾值

if (t > threshold)

threshold = tableSizeFor(t);

}

// 已初始化，並且m元素個數大於閾值，進行擴容處理

else if (s > threshold)

resize();

// 將m中的所有元素新增至HashMap中

for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {

K key = e.getKey();

V value = e.getValue();

putVal(hash(key), key, value, false, evict);

}

put方法

HashMap只提供了put用於新增元素，putVal方法只是給put方法呼叫的一個方法，並沒有提供給使用者使用。

對putVal方法新增元素的分析如下：

①如果定位到的陣列位置沒有元素就直接插入。
②如果定位到的陣列位置有元素就和要插入的 key 比較，如果key相同就直接覆蓋，如果 key 不相同，就判斷 p 是否是一個樹節點，如果是就呼叫 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value) 將元素新增進入。如果不是就遍歷連結串列插入。

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) {

Node<K,V>[] tab; Node<K,V> p; int n, i;

// table未初始化或者長度為0，進行擴容

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

// (n - 1) & hash 確定元素存放在哪個桶中，桶為空，新生成結點放入桶中(此時，這個結點是放在陣列中)

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

// 桶中已經存在元素

else {

Node<K,V> e; K k;

// 比較桶中第一個元素(陣列中的結點)的hash值相等，key相等

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

// 將第一個元素賦值給e，用e來記錄

e = p;

// hash值不相等，即key不相等；為紅黑樹結點

else if (p instanceof TreeNode)

// 放入樹中

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

// 為連結串列結點

else {

// 在連結串列最末插入結點

for (int binCount = 0; ; ++binCount) {

// 到達連結串列的尾部

if ((e = p.next) == null) {

// 在尾部插入新結點

p.next = newNode(hash, key, value, null);

// 結點數量達到閾值，轉化為紅黑樹

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash);

// 跳出迴圈

break;

}

// 判斷連結串列中結點的key值與插入的元素的key值是否相等

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

// 相等，跳出迴圈

break;

// 用於遍歷桶中的連結串列，與前面的e = p.next組合，可以遍歷連結串列

p = e;

}

// 表示在桶中找到key值、hash值與插入元素相等的結點

if (e != null) {

// 記錄e的value

V oldValue = e.value;

// onlyIfAbsent為false或者舊值為null

if (!onlyIfAbsent || oldValue == null)

//用新值替換舊值

e.value = value;

// 訪問後回撥

afterNodeAccess(e);

// 返回舊值

return oldValue;

}

// 結構性修改

++modCount;

// 實際大小大於閾值則擴容

if (++size > threshold)

resize();

// 插入後回撥

afterNodeInsertion(evict);

return null;

}

我們再來對比一下 JDK1.7 put方法的程式碼

對於put方法的分析如下：

①如果定位到的陣列位置沒有元素就直接插入。
②如果定位到的陣列位置有元素，遍歷以這個元素為頭結點的連結串列，依次和插入的key比較，如果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;

}

get方法

public V get(Object key) {

Node<K,V> e;

return (e = getNode(hash(key), key)) == null ? null : e.value;

}

final Node<K,V> getNode(int hash, Object key) {

Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

if ((tab = table) != null && (n = tab.length) > 0 &&

(first = tab[(n - 1) & hash]) != null) {

// 陣列元素相等

if (first.hash == hash && // always check first node

((k = first.key) == key || (key != null && key.equals(k))))

return first;

// 桶中不止一個節點

if ((e = first.next) != null) {

// 在樹中get

if (first instanceof TreeNode)

return ((TreeNode<K,V>)first).getTreeNode(hash, key);

// 在連結串列中get

do {

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

return e;

} while ((e = e.next) != null);

}

return null;

}

resize方法

進行擴容，會伴隨著一次重新hash分配，並且會遍歷hash表中所有的元素，是非常耗時的。在編寫程式中，要儘量避免resize。

final Node<K,V>[] resize() {

Node<K,V>[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

int newCap, newThr = 0;

if (oldCap > 0) {

// 超過最大值就不再擴充了，就只好隨你碰撞去吧

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

// 沒超過最大值，就擴充為原來的2倍

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1; // double threshold

}

else if (oldThr > 0) // initial capacity was placed in threshold

newCap = oldThr;

else {

signifies using defaults

newCap = DEFAULT_INITIAL_CAPACITY;

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

}

// 計算新的resize上限

if (newThr == 0) {

float ft = (float)newCap * loadFactor;

newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);

}

threshold = newThr;

@SuppressWarnings({"rawtypes","unchecked"})

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

table = newTab;

if (oldTab != null) {

// 把每個bucket都移動到新的buckets中

for (int j = 0; j < oldCap; ++j) {

Node<K,V> e;

if ((e = oldTab[j]) != null) {

oldTab[j] = null;

if (e.next == null)

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

else {

Node<K,V> loHead = null, loTail = null;

Node<K,V> hiHead = null, hiTail = null;

Node<K,V> next;

do {

next = e.next;

// 原索引

if ((e.hash & oldCap) == 0) {

if (loTail == null)

loHead = e;

else

loTail.next = e;

loTail = e;

}

// 原索引+oldCap

else {

if (hiTail == null)

hiHead = e;

else

hiTail.next = e;

hiTail = e;

}

} while ((e = next) != null);

// 原索引放到bucket裡

if (loTail != null) {

loTail.next = null;

newTab[j] = loHead;

}

// 原索引+oldCap放到bucket裡

if (hiTail != null) {

hiTail.next = null;

newTab[j + oldCap] = hiHead;

}

return newTab;

}

HashMap常用方法測試

package map;

import java.util.Collection;

import java.util.HashMap;

import java.util.Set;

public class HashMapDemo {

public static void main(String[] args) {

HashMap<String, String> map = new HashMap<String, String>();

// 鍵不能重複，值可以重複

map.put("san", "張三");

map.put("si", "李四");

map.put("wu", "王五");

map.put("wang", "老王");

map.put("wang", "老王2");// 老王被覆蓋

map.put("lao", "老王");

System.out.println("-------直接輸出hashmap:-------");

System.out.println(map);

/**

* 遍歷HashMap

*/

// 1.獲取Map中的所有鍵

System.out.println("-------foreach獲取Map中所有的鍵:------");

Set<String> keys = map.keySet();

for (String key : keys) {

System.out.print(key+" ");

}

System.out.println();//換行

// 2.獲取Map中所有值

System.out.println("-------foreach獲取Map中所有的值:------");

Collection<String> values = map.values();

for (String value : values) {

System.out.print(value+" ");

}

System.out.println();//換行

// 3.得到key的值的同時得到key所對應的值

System.out.println("-------得到key的值的同時得到key所對應的值:-------");

Set<String> keys2 = map.keySet();

for (String key : keys2) {

System.out.print(key + "：" + map.get(key)+" ");

}

/**

* 另外一種不常用的遍歷方式

*/

// 當我呼叫put(key,value)方法的時候，首先會把key和value封裝到

// Entry這個靜態內部類物件中，把Entry物件再新增到陣列中，所以我們想獲取

// map中的所有鍵值對，我們只要獲取陣列中的所有Entry物件，接下來

// 呼叫Entry物件中的getKey()和getValue()方法就能獲取鍵值對了

Set<java.util.Map.Entry<String, String>> entrys = map.entrySet();

for (java.util.Map.Entry<String, String> entry : entrys) {

System.out.println(entry.getKey() + "--" + entry.getValue());


              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    BAT面試必問HashMap原始碼分析
      
                                        
                                                
HashMap 簡介 
HashMap 主要用來存放鍵值對，它基於雜湊表的Map介面實現，是常用的Java集合之一。 
JDK1 

  
 

    

    
    Java BAT大型公司面試必考技能視訊教程之HashMap原始碼分析與實現
      
                視訊通過以下四個方面介紹了HASHMAP的內容

一、 什麼是HashMap

Hash雜湊將一個任意的長度通過某種演算法（Hash函式演算法）轉換成一個固定的值。 MAP：地圖 x,y 儲存 總結：通過HASH出來的值，然後通過值定位到這個MAP，然後value儲存到這個M 

  
 

    

    
    面試必考之HashMap原始碼分析與實現
      
								
								            
							
							
							以下是JDK1.8之前版本的原始碼簡介 
一、什麼是HashMap? 
 
Hash：雜湊將一個任意的長度通過某種（hash函式演算法）演算法轉換成一個固定值。 
Map：儲存的集合、類似於地圖X，Y座 

  
 

    

    
    Spring MVC原始碼(二) ----- DispatcherServlet 請求處理流程  面試必問
      前端控制器
前端控制器，即所謂的Front Controller，體現的是設計模式中的前端控制器模式。前端控制器處理所有從使用者過來的請求。所有使用者的請求都要通過前端控制器。SpringMVC框架和其他請求驅動的表示層框架一樣，也是圍繞一個將請求分發到相應控制器的核心Servlet來設計的。Dispatc 

  
 

    

    
    HashMap原始碼分析之面試必備
      

 
    今天我們就面試會問到關於HashMap的問題進行一個彙總，以及對這些問題進行解答。
    1、HashMap的資料結構是什麼？
    2、為啥是執行緒不安全的？
  & 

  
 

    

    
    HashMap面試必問的資料結構相關知識總結
      　　如果在看這篇文章時,對HashMap的結構還不是很瞭解,建議你參考前段時間寫的《刨死你係列——HashMap剖析(基於jdk1.8)》，可能會對下面的提及到知識點有些幫助。
1：HashMap 的資料結構？
A：雜湊表結構（連結串列雜湊：陣列+連結串列）實現，結合陣列和連結串列的優點。當連結串列長度超過& 

  
 

    

    
    Java面試必問之Hashmap底層實現原理(JDK1.7)
      # 1. 前言

Hashmap可以說是Java面試必問的，一般的面試題會問:

* Hashmap有哪些特性？
* Hashmap底層實現原理(get\put\resize)
* Hashmap怎麼解決hash衝突？
* Hashmap是執行緒安全的嗎？
* ...

今天就從原始碼角度一探究竟。筆者的原始 

  
 

    

    
    Java面試必問之Hashmap底層實現原理(JDK1.8)
      # 1. 前言

上一篇從原始碼方面瞭解了JDK1.7中Hashmap的實現原理，可以看到其原始碼相對還是比較簡單的。本篇筆者和大家一起學習下JDK1.8下Hashmap的實現。JDK1.8中對Hashmap做了以下改動。

- 預設初始化容量=0
- 引入紅黑樹，優化資料結構
- 將連結串列頭插法改為尾插法 

  
 

    

    
    Java1.7的HashMap原始碼分析-面試必備技能
      - HashMap是現在用的最多的map，HashMap的原始碼可以說是面試必備技能，今天我們試著分析一下jdk1.7下的原始碼。  
- 先說結論：陣列加連結串列


![ hashmap ](https://gitee.com/zhangbin1989/picture/raw/master/zb0009_ 

  
 

    

    
    一萬三千字的HashMap面試必問知識點詳解
      [toc]
## 概論

- HashMap 是無論在工作還是面試中都非常常見常考的資料結構。比如 Leetcode 第一題 Two Sum 的某種變種的最優解就是需要用到 HashMap 的，高頻考題 LRU Cache 是需要用到 LinkedHashMap 的。HashMap 用起來很簡單，所以今天我們 

  
 

    

    
    面試必問之JVM原理
      清理   返回結果   機器碼   抽象   手機   最長   ()   參數配置   包括   1：什麽是JVM
JVM是Java Virtual Machine（Java虛擬機）的縮寫，JVM是一種用於計算設備的規範，它是一個虛構出來的計算機，是通過在實際的計算機上仿真模擬各種計算機功能來實現的。Jav 

  
 

    

    
    【面試必問】python實例方法、類方法@classmethod、靜態方法@staticmethod和屬性方法@property區別
      區別   實例   實例變量   對象   s參數   pro   當前   靜態方法   實例方法   【面試必問】python實例方法、類方法@classmethod、靜態方法@staticmethod和屬性方法@property區別
1、#類方法@classmethod，只能訪問類變量，不能訪問實例變量 

  
 

    

    
    (轉)ThreadLocal-面試必問深度解析
       
  
  ThreadLocal是什麼 
  ThreadLocal是一個本地執行緒副本變數工具類。主要用於將私有執行緒和該執行緒存放的副本物件做一個對映，各個執行緒之間的變數互不干擾，在高併發場景下，可以實現無狀態的呼叫，特別適用於各個執行緒依賴不通的變數值完成操作的場景。 
  從資料結構入手 
   

  
 

    

    
    面試必問的Spring AOP原理、SpringMVC過程
       
 
  
   
 Spring AOP ，SpringMVC ，這兩個應該是國內面試必問題，網上有很多答案，其實背背就可以。但今天筆者帶大家一起深入淺出原始碼，看看他的原理。以期讓印象更加深刻，面試的時候遊刃有餘。 
 Spring AOP 原理 
 簡單說說 AOP 的設計： 
 
  每個 

  
 

    

    
    什麼是Spring?它有哪些好處？ (現在基本上是面試必問了)
       
 
 什麼是Spring?它有哪些好處？ 
 Spring是一個輕量級控制反轉（IOC）和麵向切面（AOP）的容器框架， 
 它主要是為瞭解決企業應用開發的複雜性而誕生的： 
 目的：解決企業級應用開發的複雜性。 
 功能：使用基本的JavaBean代替EJB。 
 範圍：任何Java應用。 
 &nbs 

  
 

    

    
    【面試必問】支撐百萬併發的"IO多路複用"技術你瞭解嗎？
      
 多路複用其實並不是什麼新技術，它的作用是在一個通訊連線的基礎上可以同時進行多個請求響應處理。對於網路通訊來其實不存在這一說法，因為網路層面只負責資料傳輸；由於上層應用協議的制訂問題，導致了很多傳統服務並不能支援多路複用；如：http1.1,sqlserver和redis等等，雖然有些服務提供批量處理，但這 

  
 

    

    
    面試必問：程序與執行緒的異同以及程序間通訊方式
       
 
  
  
 秋招面試必問的題目，感覺今年被問了差不多10次了。 
 1.程序與執行緒 
 程序：具有獨立功能的程式關於某個資料集合上的一次執行活動。 執行緒：程序的一個實體。 比喻：一列火車是一個程序，火車的每一節車廂是執行緒。 
 2.程序與執行緒的聯絡 
 ①一個執行緒只能屬於一個程序，一個程序 

  
 

    

    
    java集合之----HashMap原始碼分析（基於JDK1.7與1.8）
       
  
  
 一、什麼是HashMap 
 百度百科這樣解釋：  簡而言之，HashMap儲存的是鍵值對（key和value），通過key對映到value，具有很快的訪問速度。HashMap是非執行緒安全的，也就是說在多執行緒併發環境下會出現問題（死迴圈） 
 二、內部實現 
 （1）結構 
 HashM 

  
 

    

    
    網際網路公司面試必問的mysql題目(上)
      
1、 FROM：對 FROM 子句中的前兩個表執行笛卡爾積(交叉聯接)，生成虛擬表 VT1。2、 ON：對 VT1 應用 ON 篩選器，只有那些使為真才被插入到 TV2。3、 OUTER (JOIN):如果指定了 OUTER JOIN(相對於 CROSS JOIN 或 INNER JOIN)，保留表中未找 

  
 

    

    
    HashMap原始碼分析
      目錄

目錄
1. 概述
HashMap是一種key/value形式的儲存結構. 它綜合了陣列(查詢容易, 插入和刪除困難)和連結串列(插入和刪除容易, 查詢困難)的特點.
HashMap的核心點就是hash演算法和紅黑樹演算法.
HashMap是無序的.
2. 儲存結構
HashMap的儲存結構為陣列 +


        
      
    
    
  
    搜尋
    
        
      
      
    
  
 
  
  
    基礎教學
     
    Mysql入門  
     Sql入門 
      Android入門 
       Docker入門 
        Go語言入門 
         Ruby程式入門 
          Python入門 
           Python進階 
            Django入門 
             Python爬蟲入門 
             
      
      
  
   
  
    最近訪問
    
  	      
  
      
    
  

 

 


  
    
      
        
          首頁
前端設計
程式設計
免費資源
實用技巧
資料庫
資訊
字典
        
          Copyright © 2002-2020  程式人生 796T.COM All rights reserved.