2、HashMap源碼分析

来源:https://www.cnblogs.com/knowledgeispower/archive/2023/02/17/17130618.html
-Advertisement-
Play Games

特別：下文的“容量”、“數組長度”，“capacity” 都是指底層數組長度，即 table.length 1 一般數據結構及特點 數組：占用連續記憶體的數據結構，查找容易[O(1)]，插入困難[O(n)] 鏈表：由一組指向（單向或者雙向）的節點連接的數據結構，記憶體不連續，查找困難，但插入刪除容易 哈 ...


目錄

特別：下文的“容量”、“數組長度”，“capacity” 都是指底層數組長度，即 table.length

1 一般數據結構及特點

  1. 數組：占用連續記憶體的數據結構，查找容易[O(1)]，插入困難[O(n)]
  2. 鏈表：由一組指向（單向或者雙向）的節點連接的數據結構，記憶體不連續，查找困難，但插入刪除容易
  3. 哈希表：插入刪除查找都容易的數據結構
  4. 數組下標是通過：（Node<K, V>[] 的容量-1）&（hash(key)）的出來的

本章要解決的問題：

  • HashMap的數據結構實現方式
  • HashMap是怎麼做到為get、put操作提供穩定的時間複雜度的
  • HashMap什麼時候從單節點轉成鏈表又是什麼時候從鏈表轉成紅黑樹
  • HashMap初始化時為什麼要給自定義的初始容量。
  • HashMap如何保證容量始終是2的冪
  • HashMap為何要保證容量始終是2的冪
  • HashMap的hash值如何計算
  • HashMap為什麼是線程不安全的

2 HashMap基本屬性說明

常量部分：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 預設初始容量 16
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; //預設載入因數
static final int TREEIFY_THRESHOLD = 8;  //鏈表轉紅黑樹閾值
static final int UNTREEIFY_THRESHOLD = 6; //紅黑樹轉鏈表閾值
static final int MIN_TREEIFY_CAPACITY = 64;  //鏈表轉轉紅黑樹的數組最小容量
transient int size; //HashMap的元素個數
  • default_initial_capacity：初始容量=16
  • maximum_capacity：最大容量=1<<30。
  • default_load_factor：負載因數=0.75。
  • threshold：下一個觸發擴容操作的閾值，threshold = capacity * load_factor。當元素數量(size值)超過閾值時觸發擴容，新容量是舊容量2倍。
  • treeify_threshold：鏈表轉紅黑樹時鏈表長度閾值=8
  • untreeify_threshold： 紅黑樹轉鏈表閾值=6，紅黑樹節點小於6就會轉成鏈表。
  • Node<K, V> implements Map.Entry<K, V> ：HashMap存放數據的基本單位，裡面存有hash值、key、value、next。
  • Node<K, V>[] table：存放Node節點的數組，HashMap底層數組，數組元素可以為單節點Node、多節點鏈表、多節點紅黑樹。
  • size：成員變數，表示當前Map的鍵值對數量，在put、remove、clear操作，會修改該值。擴容也是通過閾值跟size進行比較決定

3 HashMap 數據結構

  • HashMap是一個Node類型的數組，每個元素可以為單節點、鏈表、紅黑樹。

  • Java8之前，HashMap的數據結構如下：

數組+鏈表：鏈表是為瞭解決hash衝突

  • Java8，HashMap的數據結構如下：
    數組+鏈表+紅黑樹

3.1構造函數

Tips：

  1. 確定載入因數
  2. 根據初始容量參數重新計算擴容閾值（大於或等於初始容量且一定等於2的冪的那個數）
    tableSizeFor(initialCapacity):確定擴容閾值：大於或等於初始容量且一定等於2的冪的那個數；比如cap=8則返回8；cap=9則返回16

源碼分析如下：

//構造函數一：無參構造函數：載入因數（0.75）和初始容量（16）分別使用預設值
public HashMap() {
	this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//構造函數二：
//指定初始容量，調用HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//構造函數三：同時指定初始容量和載入因數
public 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;
    //  確定擴容閾值：大於或等於初始容量且一定等於2的冪的那個數；比如cap=8則返回8；cap=9則返回16
    this.threshold = tableSizeFor(initialCapacity);
}
//構造函數三：創建一個跟參數有相同結構的map
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

3.2 Node<k,v>分析

tips：一個簡單的K-V模型的數據體，提供對key value的set get操作
源碼如下：

/**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    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;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value); // key value 的hash值再做異或運算
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        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;
        }
    }

4 put過程分析

4.1 擴容方法resize()分析

HashMap的容量變化通常存在以下幾種情況：

  1. 空參數的構造函數：實例化的HashMap預設內部數組是null，即沒有實例化。第一次調用put方法時，則會開始第一次初始化擴容，長度為16。【懶載入】

  2. 有參構造函數：用於指定容量。根據閾值計算方式【大於或等於初始容量且一定等於2的冪的那個數】，將這個數設置賦值給閾值。第一次調用put方法時，會將閾值賦值給容量（第一步），然後讓 閾值=負載因數X容量（第二步）
     。（因此並不是我們手動指定了容量就一定不會觸發擴容，超過閾值後一樣會擴容！！）

  3. 如果不是第一次擴容，則容量變為原來的2倍，閾值也變為原來的2倍。（負載因數還是不變）

  4. 首次put時，先會觸發擴容（底層table初始化），然後存入數據，然後判斷是否需要擴容；不是首次put，則不再初始化，直接存入數據，然後再判斷是否需要擴容；

參看源碼：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//當前數組
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //非首次put，擴容閾值變為原來2倍；容量變為原來的2倍
        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; // 將擴容閾值變為原來2倍
        }
        
        //第一次 put 的時候，【對應使用 new HashMap(int initialCapacity) 初始化後】
        else if (oldThr > 0) 
            newCap = oldThr; //如果初始化Map時指定了初始容量，則數組容量=擴容閾值（參照閾值的計算）
        
        //第一次 put 的時候 ，【對應使用 new HashMap() 初始化後】
        else {
            newCap = DEFAULT_INITIAL_CAPACITY;//沒有指定初始容量，則數組容量=預設初始容量
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//擴容閾值=載入因數*預設初始容量=12
        }

        //第一次put且有指定初始容量時 ：重新計算擴容閾值：新擴容閾值=載入因數*新數組長度
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;

       //計算好容量初始化一個新的數組
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        //如果第一次put，這裡就直接返回newTab，擴容過程結束；
        table = newTab;
        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)//數組當前位置不存在鏈表或者紅黑樹，則直接put到該位置
                        newTab[e.hash & (newCap - 1)] = e; //返回單節點的Node數組
                    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;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

4.2 put方法分析

源碼分析：

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

    /**
     * @param hash：key的hash值
     * @param onlyIfAbsent  ：false表示key存在時，覆蓋value
     * @param evict if false, the table is in creation mode.  待補充
     */
    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)
           //第一次put，先執行數組初始化操作
            n = (tab = resize()).length;
        //當前key對應的數組下標沒有元素，則直接初始化新的Node到該數組位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null); //註意此時Node沒有Next
        else {
        //當前key對應的數組下標已經存在元素
            Node<K,V> e; K k;
            // 情況一：//該位置的元素跟新put進來的數據key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;    //註意這裡是引用的賦值，因此後面e.value=value可以實現value覆蓋
            //情況二：當前位置是紅黑樹結構
            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) {
                        //創建新的Node並放在鏈表的末端
                        p.next = newNode(hash, key, value, null);
                        // treeify_threshold 為 8，所以，如果新插入的值是鏈表中的第 8 個，將鏈表轉換為紅黑樹
                        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; //這裡break，代碼後面統一對e進行value的覆蓋處理
                    //此時既未遍歷到鏈表末端，也沒有發現key相等，則繼續鏈表遍歷
                    p = e;   //這個賦值，相當於鏈表的遍歷，尾部指向下一個節點的頭部，實現鏈表遍歷
                }
            }
            if (e != null) { // existing mapping for key  key相等時
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;  //新的value覆蓋舊的value值
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
        //每次put操作完成後，size自增；
        //如果size超過閾值，則在put完成後，再次執行擴容
            resize();
        afterNodeInsertion(evict);//父類抽象方法的實現，HashMap不做任何實現
        return null;
    }
  • 第一次put時擴容過程如下：
容量：C
載入因數：F
擴容閾值：T

------ 1、無參初始化：
F=0.75
C=0
T=0

------ 2、有參初始化：容量參數=7
F=0.75
C=0
T=tableSizeFor(7)=8  //1、2、4、8 。。。大於7 所以取8

------ 3、第一次put && 無參初始化時
F=0.75
C=16（預設容量）
T=16*0.75=12

------ 4、第一次put && 有參初始化時
F=0.75
C=T=8 // 容量=閾值
T=8*0.75=6 // 閾值更新：容量*載入因數

5 關於HashMap

5.1 HashMap如何實現put、get操作時間複雜度為O(1)~O(n)?

  1. 首先，對於數組的元素，如果知道index，那查找的複雜度就是O(1)級別
  2. 對於get操作，首先根據key計算出hash值，而這個hash值 執行操作hash&(n-1)就是它所在的index，在最好的情況下，該index只有一個節點且hash值與key的hash值相等，那麼時間的複雜度就是O(1)。當該節點為鏈表或者紅黑樹時，時間複雜度會上升，但是由於HashMap的優化（鏈表長度、紅黑樹長度相對HashMap容量不會過長，過長會觸發resize操作），所以 最壞的情況也就是O(n) ,可能還會小於這個值。【鏈表的查詢時間複雜度是：O (n)，紅黑樹是 O(logN)，比O (n)更小】
  3. 對於put操作，我們知道，數組插入元素的成本是高昂的，HashMap巧妙的 使用鏈表和紅黑樹代替了數組插入元素需要移動後續元素的消耗，這樣在最好的情況下，插入一個元素，該index位置恰好沒有元素的話，時間複雜度就是O(1),當該位置有元素且為鏈表或者紅黑樹的情況下，時間複雜度會上升，但是最壞的情況下也就是O(n)。

5.2 HashMap什麼時候從單節點轉成鏈表又是什麼時候從鏈表轉成紅黑樹？

  1. 單節點轉鏈表：當計算出來的index處有元素，且元素是單節點時，則該節點變為鏈表；
  2. 鏈表轉紅黑樹有兩個條件：
    1. 鏈表長度大於TREEIFY_THRESHOLD，預設閾值是8；
    2. HashMap長度大於64

5.3 HashMap初始化時為什麼要給自定義的初始容量？

  1. 不指定初始容量時，HashMap底層數組的在第一次put值時，數組長度為預設初始長度即16，載入因數為0.75，擴容閾值為16*0.75=12；當元素數量大於12時，底層數組進行擴容，長度翻倍為32，擴容閾值翻倍為24，依次類推；
  2. 指定初始容量時，假設初始容量為C=1000。HashMap底層數組的在第一次put值時，數組長度初始化為 1024，擴容閾值為1024*0.75=768；當元素數量大於768時，底層數組進行擴容，長度和閾值同時翻倍。
  3. 因此，當HashMap元素足夠多時，不指定初始容量要比指定初始容量進行更多次的擴容，擴容涉及數組拷貝、鏈表或紅黑樹重建，消耗更多性能。
  4. 根據要使用的HashMap大小確定初始容量，這也不是說為了避免擴容初始容量給的越大越好， 越大申請的記憶體就越大，如果你沒有這麼多數據去存，又會造成hash值過於離散，增加查詢或修改的時間複雜度。

5.4 HashMap如何保證容量始終是2的冪？

HashMap使用方法tableSizeFor()來保證無論你給值是什麼，返回的一定是2的冪

/**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

5.5 HashMap為何要保證容量始終是2的冪

  1. HashMap在定位元素在數組的index時，運算公式是 (n-1)&hash ,n為數組的長度。如果容量始終是2的次冪，例如 0000 0000 0000 0000 0000 0000 1000 0000，則n-1的二進位形式為：0000 0000 0000 0000 0000 0000 0111 1111 ，低位區一定是1，在進行 (n-1)&hash，hash低位區的0、1特征能夠保留
  2. 因此，容量始終是2的冪，這樣 下標index值的取值範圍更廣，減少hash碰撞。

5.6 HashMap計算hash值

1、帶著疑問：
key的hashCode為什麼右移16位後再進行異或運算？

2、關於 | & ^ 三種運算的特征說明：

  • ^按位異或運算：位相同返回0，不同返回1；可推導出：任何數跟0異或返回任何數，任何數跟1異或返回對應的取反
  • 異或運算能更好的保留各部分的特征，如果採用邏輯與&運算計算出來的值會向0靠攏（00得0，01得0，11得1 因此0的概率2/3），採用邏輯或|運算計算出來的值會向1靠攏 (00得0，01得1，11得1，因此1的概率為2/3)

3、hash()源碼：

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    //key.hashCode() ;hashCode是Object對象的一個native方法，由操作系統實現，跟記憶體地址存在某種映射關係

4、進入分析：

5.6.1 key的hash值>>>16，為什麼要這樣做呢？

  1. h值右移16後，高16位都為0，這樣h^(h>>>16)時，高16位的值不會有任何變化，但是低16位的值混雜了key的高16位的值，從而增加了hash值的複雜度，進一步減少了hash值一樣的概率。
  2. 計算數組下標公式：(n-1)&hash，n-1的結果：高位趨於0；&運算的結果：高16位向0靠攏，hash的高位特征丟失
  3. 因此，如果我們不做hash值的移位和異或運算，那麼在計算數組index時將丟失高區特征

簡單點：

因為：(n-1)&hash中，hash的高位數將被數組長度的二進位碼鎖屏蔽，為確保hash的高位儘可能利用，就先對hash值先右移16位，再跟原hash值進行異或運算，同時保留高位和低位特征。

數組長度二進位碼屏蔽是什麼意思？

數組長度的數據類型int轉化為32位的二進位，因為長度值對比最大值（2的32位）總是比較小的，所以它的高位趨向0，與其他數進行&運算後，結果值的高位趨向0，那麼其他數的高位特征就丟失了

下麵用例子分析：

### 計算hash
hashCode：     					0000 0000 0101 0000 0000 0000 1111 1010
hashCode>>>16: 					0000 0000 0000 0000 0000 0000 0101 0000
hashCode^hashCode>>>16: 		0000 0000 0101 0000 0000 0000 0110 1010

hash=hashCode^hashCode>>>16 	0000 0000 0101 0000 0000 0000 0110 1010

### 計算index時：
(n-1) (假設n=16)            		0000 0000 0000 0000 0000 0000 0000 1111  
(n-1)&hash                  	0000 0000 0000 0000 0000 0000 0000 1010

仔細觀察上文不難發現，高16位很有可能會被數組長度的二進位碼鎖屏蔽，
如果我們不做移位異或運算，那麼在計算數組index時將丟失高區特征

5.7 HashMap為什麼是線程不安全的？

  1. 它沒有任何的鎖或者同步等多線程處理機制，無法控制併發下導致的線程衝突。
  2. 如果想要線程安全的使用基於hash表的map，可以使用ConcurrentHashMap，該實現get操作是無鎖的，put操作也是分段鎖，性能很好

6 get 過程分析

  1. 計算 key 的 hash 值，根據 hash 值找到對應數組下標: hash & (length-1)
  2. 判斷數組該位置處的元素是否剛好就是我們要找的，如果不是，走第三步
  3. 判斷該元素類型是否是 TreeNode，如果是，用紅黑樹的方法取數據，如果不是，走第四步
  4. 遍歷鏈表，直到找到相等(==或equals)的 key

參考資料：

  1. [良許-HashMap源碼實現分析]：https://www.cnblogs.com/yychuyu/p/13357218.html

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 拜占庭將軍問題和 Raft 共識演算法講解
    在分散式系統中， 什麼是拜占庭將軍問題？產生的場景和解決方案是什麼？什麼是 Raft 共識演算法？Raft 演算法是如何解決拜占庭將軍問題的？其核心原理和演算法邏輯是什麼？除了 Raft，還有哪些共識演算法？共識問題作為分散式系統的一大難點和痛點，本文主要介紹了其產生的背景、原因，以及通用的 Raft 演算法... ...
  • 多線程併發（一）：以AQS中acquire()方法為例來分析多線程間的同步與協作
    談到java中的併發，我們就避不開線程之間的同步和協作問題，談到線程同步和協作我們就不能不談談jdk中提供的AbstractQueuedSynchronizer(翻譯過來就是抽象的隊列同步器)機制； (一)、AQS中的state和Node含義： AQS中提供了一個int volatile state ...
  • 讀Java實戰（第二版）筆記13_Java模塊系統
    題目來源：https://www.acwing.com/problem/content/description/789/ 題目描述 給定你一個長度為 n 的整數數列。 請你使用歸併排序對這個數列按照從小到大進行排序。 並將排好序的數列按順序輸出。 輸入格式 輸入共兩行，第一行包含整數 n。 第二行包 ...
  • day12-SpringMVC文件上傳
    SpringMVC文件上傳 1.基本介紹 SpringMVC 為文件上傳提供了直接的支持，這種支持是通過即插即用的 MultipartResolver 實現的。spring 用 Jacarta Commons FileUpload 技術實現了一個 MultipartResolver 的實現類：Com ...
  • 用Python做一個小說下載器，從獲取數據到編寫GUI界面
    對於廣大書蟲而言，沒有小說看是最痛苦的，你身邊有這樣的人嗎？ 今天咱們分享一個小說下載器代碼，打包成exe後，發給你的小伙伴也能直接使用… 思路流程 什麼是爬蟲? 按照一定的規則, 去採集互聯網上面數據 爬蟲可以做什麼? 採集數據: 定製化採集數據 自動化腳本：自動點贊/評論/刷票/商品搶購腳本/自 ...
  • Flink CDC 監聽 Postgresql表的變化
    系列內容 elasticsearch 概述 elasticsearch 安裝 elasticsearch 查詢 客戶端api使用 1. elasticsearch 概述 1.1 簡介 官網: https://www.elastic.co/ Elasticsearch (簡稱ES)是一個分散式、RES ...
  • 3、TreeMap源碼解析
    1 TreeMap基本介紹 Java TreeMap實現了SortedMap介面，也就是說會按照key的大小順序對Map中的元素進行排序 key大小的評判可以通過其本身的自然順序(natural ordering)，也可以通過構造時傳入的比較器(Comparator)。 TreeMap底層通過紅黑樹 ...
  • 關於靜態代碼塊和匿名代碼塊以及結構體在程式運行過程中的調用順序實驗（續）
    關於靜態代碼塊和匿名代碼塊以及結構體在程式運行過程中的調用順序實驗（續） 之前發過一篇博客講述自己對靜態代碼塊、匿名代碼塊以及結構體在程式中運行結果的小實驗。本次再接觸到abstract抽象類後，覺得在做一個實驗，看看抽象類方法繼承中三個模塊的調用順序。所編寫的代碼如下： Application類（ ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類