個人面試準備過程--容器(更新中)
ArrayList
ArrayList底層實現是對象數組，優勢是set、get時間爲O(1)，缺點是add和remove時間爲O(n)，須要留意的是擴容的過程以及remove的算法node
public class MyArrayList<E>{
private static final int DEFAULT_CAPACITY = 10;
Object[] elementData;
int size;
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
public boolean contains(Object o){
return indexOf >= 0;
}
public E remove(int index){
rangeCheck(index);
E oldValue = elementData[index];
int numMoved = size - index - 1;
if(numMoved > 0){
System.copyarray(elementData, index + 1, elementData, index, numMoved);
}
elementData[--size] = null;
return oldValue;
}
public boolean remove(Object o){
if(o == null){
for(int i = 0; i < size; i++){
fastRemove(i);
return true;
}
}else{
for(int i = 0; i < size; i++){
fastRemove(i);
return true;
}
}
return false;
}
public void fastRemove(int index){
int numMoved = size - index - 1;
if(numMoved > 0){
System.copyarray(elementData, index + 1, elementData, index, numMoved);
}
elementData[--size] = null;
}
public boolean add(E e){
ensureCapacity(size + 1);
elementData[size++] = e;
return true;
}
public E get(int index){
rangeCheck(index);
return elementData[index];
}
public E set(int index, E element){
rangeCheck(index);
E oldValue = elementData[index];
elementData[index] = element;
return oldValue;
}
public void ensureCapacity(int minCapacity){
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
if(minCapacity - elementData.length > 0){
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private int hugeCapacity(int minCapacity){
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(index){
return "Size:" + size + ", Index:" + index;
}
public int indexOf(Object o){
if(o == null){
for(int i = 0; i < size; i++){
if(elementData[i] == null){
return i;
}
}
}else{
for(int i = 0; i < size; i++){
if(elementData[i].equals(o)){
return i;
}
}
}
return -1;
}
}
本節參考 jdk1.8 源碼算法
HashMap
table中放Entry（最新的JDK源碼爲Node），Entry組成鏈表或紅黑樹segmentfault
Entry(Node定義)
static class Node<K, V> implements Map.Entry<K, V>{
final int 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;
}
}
從總體上看，HashMap底層的存儲結構是基於數組和鏈表實現的。對於每個要存入HashMap的鍵值對（Key-Value Pair），經過計算Key的hash值來決定存入哪一個數組單元（bucket），爲了處理hash衝突，每一個數組單元其實是一條Entry單鏈表的頭結點，其後引伸出一條單鏈表。數組
存取過程
取值過程大體以下：先檢查table中的頭結點，table中若是是樹，從樹中找；否則從鏈表中找安全
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 &&
((k = first.key)) == key || (key != null && key.equals(k))))
return first;
if((e = first.next) != null){
//若是爲紅黑樹，按樹遍歷
if(first instanceof TreeNode)
return ((treeNode<K, V>) first).getTreeNode(hash, key);
do{
if(e.hash == hash &&
(k = e.key) == key || (key != null && key.equals(k)))
return e;
}while((e = e.next) != null);
}
}
return null;
}
添加鍵值對put(key,value)的過程：
1，判斷鍵值對數組tab[]是否爲空或爲null，不然以默認大小resize()；
2，根據鍵值key計算hash值獲得插入的數組索引i，若是tab[i]==null，直接新建節點添加，不然轉入3
3，判斷當前數組中處理hash衝突的方式爲鏈表仍是紅黑樹(check第一個節點類型便可),分別處理多線程
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*若是table的在（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;
/*檢查第一個Node，p是否是要找的值*/
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;
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);
//若是衝突的節點數已經達到8個，看是否須要改變衝突節點的存儲結構，
//treeifyBin首先判斷當前hashMap的長度，若是不足64，只進行
//resize，擴容table，若是達到64，那麼將衝突的存儲結構爲紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/*若是有相同的key值就結束遍歷*/
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
/*就是鏈表上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*若是當前大小大於門限，門限本來是初始容量*0.75*/
if (++size > threshold)
resize();//擴容兩倍
afterNodeInsertion(evict);
return null;
}
擴容機制resize()
構造hash表時，若是不指明初始大小，默認大小爲16（即Node數組大小16），若是Node[]數組中的元素達到（填充比*Node.length）從新調整HashMap大小 變爲原來2倍大小,擴容很耗時,須要從新計算bucket的位置。app
爲何經過計算h & (length-1)來得到bucket的位置，而不是經過計算h % length？函數
實際上，在HashMap中，h & (length-1) == h % length，可是須要一個前提：length必須知足是2的冪。這也正是在解釋DEFAULT_INITIAL_CAPACITY和HashMap構造方法時強調的HashMap的bucket容量必須是2的冪。當length是2的冪，那麼length的二進制數能夠表示爲1000...000，所以length - 1的二進制數爲0111...111，當h與length - 1位與時，除了h的最高位的被修改成0，其他位均保持不變，這也正是實現了h % length的效果。只是相比於h % length，h & (length-1)的效率會更高。性能
HashMap的bucket容量必須爲2的冪的另外一個重要緣由是一旦知足此條件，那麼length即爲偶數，length - 1便爲奇數，因此length - 1的最後一位必爲1。所以，h & (length - 1)獲得的值既多是奇數，也多是偶數，這確保了散列的均勻性。若是length - 1是偶數，那麼h & (length - 1)獲得的值必爲偶數，那麼HashMap的空間便浪費了一半。this
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;
}
/*把新表的長度設置爲舊錶長度的兩倍，newCap=2*oldCap*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
/*把新表的門限設置爲舊錶門限的兩倍，newThr=oldThr*2*/
newThr = oldThr << 1; // double threshold
}
/*若是舊錶的長度的是0，就是說第一次初始化表*/
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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;//把新表賦值給table
if (oldTab != null) {//原表不是空要把原表中數據移動到新表中
/*遍歷原來的舊錶*/
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)//說明這個node沒有鏈表直接放在新表的e.hash & (newCap - 1)位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
/*若是e後邊有鏈表,到這裏表示e後面帶着個單鏈表，須要遍歷單鏈表，將每一個結點重*/
else { // preserve order保證順序
////新計算在新表的位置，並進行搬運
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;//記錄下一個結點
//新表是舊錶的兩倍容量，實例上就把單鏈表拆分爲兩隊，
//e.hash&oldCap爲偶數一隊，e.hash&oldCap爲奇數一對
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {//lo隊不爲null，放在新表原位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//hi隊不爲null，放在新表j+oldCap位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
HashMap的總結
本節參考
HashMap的默認大小爲16，即桶數組的默認長度爲16；
HashMap的默認裝載因子是0.75；
HashMap內部的桶數組存儲的是Entry對象，也就是鍵值對對象。
構造器支持指定初始容量和裝載因子，爲避免數組擴容帶來的性能問題，建議根據需求指定初始容量。裝載因子儘可能不要修改，0.75是個比較靠譜的值。
桶數組的長度始終是2的整數次方（大於等於指定的初始容量），這樣作能夠減小衝突機率，提升查找效率。（能夠從indexfor函數中看出，h&(length-1),若length爲奇數，length-1爲偶數那麼h&(length-1)結果的最後一位必然爲0，也就是說全部鍵都被散列到數組的偶數下標位置,這樣會浪費近一半空間。另外，length爲2的整數次方也保證了h&(length-1)與h%length等效）.
HashMap接受null鍵；
HashMap不容許鍵重複，可是值是能夠重複的。若鍵重複，那麼新值會覆蓋舊值。
HashMap經過鏈表法解決衝突問題，每一個Entry都有一個next指針指向下一個Entry，衝突元素（不是鍵相同，而是hash值相同）會構成一個鏈表。而且最新插入的鍵值對始終位於鏈表首部。
當容量超過閾值（threshold）時,會發生擴容，擴容後的數組是原數組的兩倍。擴容操做須要開闢新數組，並對原數組中全部鍵值對從新散列，很是耗時。咱們應該儘可能避免HashMap擴容。
HashMap非線程安全。
線程安全與HashTable
HashMap是一個非線程安全的，所以適合運用在單線程環境下。若是是在多線程環境，能夠經過Collections的靜態方法synchronizedMap得到線程安全的HashMap，以下代碼所示。
Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
HashTable和HashMap底層採用相同的存儲結構，在不少方法的實現上兩者的思路基本一致。最主要的區別主要有兩點。
HashTable實現了所謂的線程安全，在HashTable不少方法上都加上了synchronized。
在HashMap的分析中，咱們發現當咱們新增鍵值對時，HashMap是容許Key和Value均爲null。可是HashTable不容許Key或Value爲null，關於這一點咱們能夠經過查看HashTable源碼得知。
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) { // 若value爲空則拋出NullPointerException。
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode(); // 若key爲空則拋出NullPointerException。
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
關於HashSet
HashSet基於HashMap實現；而Map是鍵值對形式的，所以構造一個PRESENT僞裝爲值。
private static final Object PRESENT = new Object();
另外，
HashSet無序；容許值爲null；非線程安全；底層增刪等操做基於HashMap實現；
LinkedHashSet有序；容許值爲null；非線程安全；依賴於HashSet，底層增刪等操做基於LinkedHashMap實現；
TreeSet有序；不容許爲null；非線程安全；底層增刪等操做基於TreeMap實現。
本節參考 https://segmentfault.com/a/11...
http://blog.csdn.net/tuke_tuk...
- 1. 個人面試準備過程--LeetCode(更新中)
- 2. 個人面試準備過程--排序算法(更新中)
- 3. 個人面試準備過程--隊列與棧(更新中)
- 4. 個人面試準備過程---字符串相關(更新中)
- 5. 個人面試準備過程--leetcode樹
- 6. 面試準備 --- 持續更新中
- 7. 個人面試準備過程--ubuntu使用過程記錄
- 8. 個人面試準備過程--JVM相關
- 9. android 面試準備內容
- 10. 2021年個人前端面試準備
- 更多相關文章...
- • ADO 更新記錄 - ADO 教程
- • Docker 容器連接 - Docker教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • Docker容器實戰(六) - 容器的隔離與限制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven