public class HashMapExam {
    public static void main(String[] args) {

        Map<Integer, String> map = new HashMap<>();
        for (int i = 0; i < 15; i++) {
            map.put(i, new String(new char[]{(char) ('A'+ i)}));
        }


        System.out.println("======Key和Value=======");
        for (Integer key:map.keySet()) {
            System.out.println(key);
        }
        for (String value:map.values()) {
            System.out.println(value);
        }

        System.out.println("======Iterator迭代器=======");
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> mapEntry = iterator.next();
            System.out.println(mapEntry.getKey()+ "====" + mapEntry.getValue());
        }

        System.out.println("======Get的方式=======");
        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            System.out.println(key + "====" + map.get(key));
        }
        
        System.out.println("======forEach=======");
        map.forEach((key,value) -> System.out.println(key+ "----" + value));
    }
}

// 序列化版本號(hào)
private static final long serialVersionUID = 362498820763181265L;

// 默認(rèn)的初始容量是16 --> 1<<4 相當(dāng)于 1*2的4次方也就是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

// 最大容量（傳入容量過(guò)大將被這個(gè)替換）
static final int MAXIMUM_CAPACITY = 1 << 30;

// 默認(rèn)加載因子為0.75，通過(guò)這個(gè)來(lái)算出臨界值
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 當(dāng)桶（bucket）上的結(jié)點(diǎn)數(shù)大于這個(gè)值時(shí)會(huì)轉(zhuǎn)換成紅黑樹(shù)
static final int TREEIFY_THRESHOLD = 8;

// 當(dāng)桶(bucket)上的結(jié)點(diǎn)數(shù)小于這個(gè)值時(shí)樹(shù)轉(zhuǎn)鏈表
static final int UNTREEIFY_THRESHOLD = 6;

// 桶中結(jié)構(gòu)轉(zhuǎn)化為紅黑樹(shù)對(duì)應(yīng)的數(shù)組長(zhǎng)度最小的值 
static final int MIN_TREEIFY_CAPACITY = 64;

//存儲(chǔ)元素的數(shù)組 
transient Node<K,V>[] table;

//存放具體元素的集合
transient Set<Map.Entry<K,V>> entrySet;

//存放元素的個(gè)數(shù)，注意這個(gè)不等于數(shù)組的長(zhǎng)度。
 transient int size;

// 每次擴(kuò)容和更改map結(jié)構(gòu)的計(jì)數(shù)器
 transient int modCount;  

// 臨界值 當(dāng)實(shí)際大小(容量*負(fù)載因子)超過(guò)臨界值時(shí)，會(huì)進(jìn)行擴(kuò)容
int threshold;

// 負(fù)載因子實(shí)際大小
final float loadFactor;

public HashMap() {
   this.loadFactor = DEFAULT_LOAD_FACTOR; // 將默認(rèn)的加載因子0.75賦值給loadFactor，并沒(méi)有創(chuàng)建數(shù)組
}

// 指定“容量大小”的構(gòu)造函數(shù)
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap(int initialCapacity, float loadFactor) {
    //判斷初始化容量initialCapacity是否小于0
    if (initialCapacity < 0)
        //如果小于0，則拋出非法的參數(shù)異常IllegalArgumentException
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                            initialCapacity);
    //判斷初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY-》2的30次冪
    if (initialCapacity > MAXIMUM_CAPACITY)
        //如果超過(guò)MAXIMUM_CAPACITY，會(huì)將MAXIMUM_CAPACITY賦值給initialCapacity
        initialCapacity = MAXIMUM_CAPACITY;
    //判斷負(fù)載因子loadFactor是否小于等于0或者是否是一個(gè)非數(shù)值
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        //如果滿足上述其中之一，則拋出非法的參數(shù)異常IllegalArgumentException
        throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
     //將指定的加載因子賦值給HashMap成員變量的負(fù)載因子loadFactor
    this.loadFactor = loadFactor;
    /*
    	tableSizeFor(initialCapacity) 判斷指定的初始化容量是否是2的n次冪，如果不是那么會(huì)變?yōu)楸戎?		定初始化容量大的最小的2的n次冪。這點(diǎn)上述已經(jīng)講解過(guò)。
    	但是注意，在tableSizeFor方法體內(nèi)部將計(jì)算后的數(shù)據(jù)返回給調(diào)用這里了，并且直接賦值給threshold邊			界值了。有些人會(huì)覺(jué)得這里是一個(gè)bug,應(yīng)該這樣書(shū)寫：
    	this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;
    	這樣才符合threshold的意思（當(dāng)HashMap的size到達(dá)threshold這個(gè)閾值時(shí)會(huì)擴(kuò)容）。
		但是，請(qǐng)注意，在jdk8以后的構(gòu)造方法中，并沒(méi)有對(duì)table這個(gè)成員變量進(jìn)行初始化，table的初始化被推			 遲到了put方法中，在put方法中會(huì)對(duì)threshold重新計(jì)算，put方法的具體實(shí)現(xiàn)我們下面會(huì)進(jìn)行講解
    */
    this.threshold = tableSizeFor(initialCapacity);
}
最后調(diào)用了tableSizeFor，來(lái)看一下方法實(shí)現(xiàn)：
/**
 * Returns a power of two size for the given target capacity.
   返回比指定初始化容量大的最小的2的n次冪
 */
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;
}

//構(gòu)造一個(gè)映射關(guān)系與指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
    //負(fù)載因子loadFactor變?yōu)槟J(rèn)的負(fù)載因子0.75
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}
// 最后調(diào)用了putMapEntries，來(lái)看一下方法實(shí)現(xiàn)：
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    //獲取參數(shù)集合的長(zhǎng)度
    int s = m.size();
    if (s > 0)
    {
        //判斷參數(shù)集合的長(zhǎng)度是否大于0，說(shuō)明大于0
        if (table == null)  // 判斷table是否已經(jīng)初始化
        { // pre-size
                // 未初始化，s為m的實(shí)際元素個(gè)數(shù)
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                        (int)ft : MAXIMUM_CAPACITY);
                // 計(jì)算得到的t大于閾值，則初始化閾值
                if (t > threshold)
                    threshold = tableSizeFor(t);
        }
        // 已初始化，并且m元素個(gè)數(shù)大于閾值，進(jìn)行擴(kuò)容處理
        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);
        }
    }
}

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

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

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

    static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
        ....
    }

    final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
        ....
    }

    final TreeNode<K,V> getTreeNode(int h, Object k) {
        return ((parent != null) ? root() : this).find(h, k, null);
    }

    static int tieBreakOrder(Object a, Object b) {
        ....
    }

    final void treeify(Node<K,V>[] tab) {
        ....
    }

    final Node<K,V> untreeify(HashMap<K,V> map) {
        ....
    }

    final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v) {
        ....
    }

    final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
                                  boolean movable) {
        ....
    }

    final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
        ....
    }

    static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                              TreeNode<K,V> p) {
        ....
    }

    static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                               TreeNode<K,V> p) {
        ....
    }

    static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                    TreeNode<K,V> x) {
        ....
    }

    static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
                                                   TreeNode<K,V> x) {
        ....
    }

    static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
        ....
    }
}

static final int hash(Object key) {
    int h;
    // (h = key.hashCode()) ^ (h >>> 16)：異或Hash右移16位算法
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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) {
    // 當(dāng)前 HashMap 的散列表的引用
    Node<K,V>[] tab; 
    // first：桶頭元素
    // e：用于存儲(chǔ)臨時(shí)元素
    Node<K,V> first, e;
    // n：table 數(shù)組的長(zhǎng)度
    int n; 
    // 元素中的 k
    K k;
    // 將 table 賦值給 tab，不等于 null 說(shuō)明有數(shù)據(jù)，（n = table.length）> 0 同理說(shuō)明 table 中有值
    if ((tab = table) != null && (n = tab.length) > 0 &&
        // 同時(shí)將 該位置的元素賦值為 first
        (first = tab[(n - 1) & hash]) != null) {
        // 定位到了桶的到的位置就是想要獲取的 key 對(duì)應(yīng)的，直接返回該元素
        if (first.hash == hash && 
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 到這一步說(shuō)明定位到的元素不是想要的，且該位置不僅僅有一個(gè)元素，想要判斷是鏈表還是樹(shù)
        if ((e = first.next) != null) {
            // 是否已經(jīng)樹(shù)化
            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);
        }
    }
    // 遍歷不到返回null
    return null;
}

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

/**
     * Implements Map.put and related methods.
     *
     * @param hash		key 的 hash 值
     * @param key 		key 值
     * @param value 	value 值
     * @param onlyIfAbsent true：如果某個(gè) key 已經(jīng)存在那么就不插了；false 存在則替換，沒(méi)有則新增。這里為 false
     * @param evict 	不用管理。我也不認(rèn)識(shí)
     * @return previous value, or null if none
     */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    // tab 表示當(dāng)前 hash 散列表的引用
    Node<K,V>[] tab; 
    // 表示具體的散列表中的元素
    Node<K,V> p; 
    // n：表示散列表數(shù)組的長(zhǎng)度
    // i：表示路由尋址的結(jié)果
    int n, i;
    // 將 table 賦值發(fā)給 tab，如果 tab == null，說(shuō)明 table 還沒(méi)有被初始化。則此時(shí)是需要去創(chuàng)建 table 的
    // 為什么這個(gè)時(shí)候才去創(chuàng)建散列表，因?yàn)榭赡軇?chuàng)建了 HashMap 時(shí)候可能并沒(méi)有存放數(shù)據(jù)，如果在初始化 HashMap 的時(shí)候創(chuàng)建散列表，勢(shì)必會(huì)造成空間的浪費(fèi)
    // 這里也就是延遲初始化的邏輯
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 如果 p == null，說(shuō)明尋址到的桶沒(méi)有元素。那么就將 key-value 封裝到 Node 中，并放到尋址到的下標(biāo)為 i 的位置
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 到這里說(shuō)明 該位置已經(jīng)有數(shù)據(jù)了，且此時(shí)可能是鏈表結(jié)構(gòu)，也可能是樹(shù)結(jié)構(gòu)
    else {
        // e 表示找到了一個(gè)與當(dāng)前要插入的 key-value 一致的元素
        Node<K,V> e; 
        // 臨時(shí)的 key
        K k;
        // p 的值就是上一步 if 中的結(jié)果即：此時(shí)的（p = tab[i = (n - 1) & hash]）不等于 null
        // p 是原來(lái)的已經(jīng)在 i 的位置的元素，且新插入的 key 是等于 p 中的 key
        // 說(shuō)明找到了和當(dāng)前需要插入的元素相同的元素（其實(shí)就是需要替換而且）
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 將 p 的值賦值給 e
            e = p;
        // 說(shuō)明已經(jīng)樹(shù)化，紅黑樹(shù)會(huì)有單獨(dú)的文章介紹，本文不再闡述
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 如果 p.next == null 說(shuō)明 p 是最后一個(gè)元素，說(shuō)明，該元素在鏈表中也沒(méi)有重復(fù)的
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    // 直接將 key-value 封裝到 Node 中并且添加到 p 的后面
                    p.next = newNode(hash, key, value, null);
                    // 當(dāng)元素已經(jīng)是 7 了，再來(lái)一個(gè)就是 8 個(gè)了，那么就需要進(jìn)行樹(shù)化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 樹(shù)化
                        treeifyBin(tab, hash);
                    break;
                }
                // 在鏈表中找到了某個(gè)和當(dāng)前元素一樣的元素，即需要做替換操作了
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                // 將e（即p.next）賦值給e，這就是為了繼續(xù)遍歷鏈表的下一個(gè)元素（沒(méi)啥好說(shuō)的）下面的有張圖幫助大家理解
                p = e;
            }
        }
        // 如果條件成立，說(shuō)明找到了需要替換的數(shù)據(jù)
        if (e != null) {
            // 這里不就是使用新的值賦值為舊的值嘛
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 這個(gè)方法沒(méi)用，里面啥都沒(méi)有
            afterNodeAccess(e);
            // HashMap put 方法的返回值是原來(lái)位置的元素值
            return oldValue;
        }
    }
    // 上面說(shuō)過(guò)，對(duì)于散列表 結(jié)構(gòu)修改次數(shù)，那么就修改 modCount 的次數(shù)
    ++modCount;
    // size 即散列表中的元素個(gè)數(shù)，添加后需要自增，如果自增后的值大于擴(kuò)容的閾值，那么就觸發(fā)擴(kuò)容操作
    if (++size > threshold)
        resize();
    // 啥也沒(méi)干
    afterNodeInsertion(evict);
    // 原來(lái)位置沒(méi)有值，那么就返回 null 唄
    return null;
}

final Node<K,V>[] resize() {
    //得到當(dāng)前數(shù)組
    Node<K,V>[] oldTab = table;
    //如果當(dāng)前數(shù)組等于null長(zhǎng)度返回0，否則返回當(dāng)前數(shù)組的長(zhǎng)度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //當(dāng)前閥值點(diǎn) 默認(rèn)是12(16*0.75)
    int oldThr = threshold;
    int newCap, newThr = 0;
    //如果老的數(shù)組長(zhǎng)度大于0
    //開(kāi)始計(jì)算擴(kuò)容后的大小
    if (oldCap > 0) {
        // 超過(guò)最大值就不再擴(kuò)充了，就只好隨你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            //修改閾值為int的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        /*
        	沒(méi)超過(guò)最大值，就擴(kuò)充為原來(lái)的2倍
        	1)(newCap = oldCap << 1) < MAXIMUM_CAPACITY 擴(kuò)大到2倍之后容量要小于最大容量
        	2）oldCap >= DEFAULT_INITIAL_CAPACITY 原數(shù)組長(zhǎng)度大于等于數(shù)組初始化長(zhǎng)度16
        */
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //閾值擴(kuò)大一倍
            newThr = oldThr << 1; // double threshold
    }
    //老閾值點(diǎn)大于0 直接賦值
    else if (oldThr > 0) // 老閾值賦值給新的數(shù)組長(zhǎng)度
        newCap = oldThr;
    else {// 直接使用默認(rèn)值
        newCap = DEFAULT_INITIAL_CAPACITY;//16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 計(jì)算新的resize最大上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    //新的閥值 默認(rèn)原來(lái)是12 乘以2之后變?yōu)?4
    threshold = newThr;
    //創(chuàng)建新的哈希表
    @SuppressWarnings({"rawtypes","unchecked"})
    //newCap是新的數(shù)組長(zhǎng)度--》32
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    //判斷舊數(shù)組是否等于空
    if (oldTab != null) {
        // 把每個(gè)bucket都移動(dòng)到新的buckets中
        //遍歷舊的哈希表的每個(gè)桶，重新計(jì)算桶里元素的新位置
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                //原來(lái)的數(shù)據(jù)賦值為null 便于GC回收
                oldTab[j] = null;
                //判斷數(shù)組是否有下一個(gè)引用
                if (e.next == null)
                    //沒(méi)有下一個(gè)引用，說(shuō)明不是鏈表，當(dāng)前桶上只有一個(gè)鍵值對(duì)，直接插入
                    newTab[e.hash & (newCap - 1)] = e;
                //判斷是否是紅黑樹(shù)
                else if (e instanceof TreeNode)
                    //說(shuō)明是紅黑樹(shù)來(lái)處理沖突的，則調(diào)用相關(guān)方法把樹(shù)分開(kāi)
                    ((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;
                    //通過(guò)上述講解的原理來(lái)計(jì)算節(jié)點(diǎn)的新位置
                    do {
                        // 原索引
                        next = e.next;
                     	//這里來(lái)判斷如果等于true e這個(gè)節(jié)點(diǎn)在resize之后不需要移動(dòng)位置
                        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;
} 

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // index 元素只有一個(gè)元素
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                // index處是一個(gè)紅黑樹(shù)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                // index處是一個(gè)鏈表，遍歷鏈表返回node
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                            (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 分不同情形刪除節(jié)點(diǎn)
        if (node != null && (!matchValue || (v = node.value) == value ||
                                (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

n = n >>> 2;
// 假設(shè)n等于-15
00000000 00000000 00000000 00001111  // 15
0000000000 00000000 00000000 00001111  //15的二進(jìn)制從高位右移2位
-------------------------------------------------
00000000 00000000 00000000 00000011 //15右移之后3

n = n >> 2;
// 假設(shè)n等于-15
00000000 00000000 00000000 00001111  // -15
11000000 00000000 00000000 0000001111  //-15的二進(jìn)制從高位右移2位
-------------------------------------------------
11000000 00000000 00000000 00000011 //-15右移之后3

n = i^j
// 假設(shè)i等于10，j 等于15
00000000 00000000 00000000 00001000  // i=10
00000000 00000000 00000000 00001100  // j=15
------------------------------------------------- 
00000000 00000000 00000000 00001000  // n=10

n = i&j
// 假設(shè)i等于10，j 等于15
00000000 00000000 00000000 00001000  // i=10
00000000 00000000 00000000 00001100  // j=15
-------------------------------------------------
00000000 00000000 00000000 00000100  // n=5