java比较两个Map内元素值是否相等 两个map比较key值是否相等

一HashMap的概述

1.1类的继承结构

*Cloneable 空接口，表示可以克隆

• Serializable 序列化
• AbstractMap提供Map实现接口
  HashMap是基于哈希表的Map接口的非同步实现。是以key-value存储形式存在。（除了不同步与允许使用null之外，HashMap和HashTable大致相同）
  HashMap的实现不是同步的，这意味着它不是线程安全的。它的key.value都可以是null.
  1.2HashMap的数据结构

在JDK1.8中，HashMap是由数组+链表+红黑树组成的

1.2.1 数组：采用一段连续存储单元来存储数据结构，对于指定下标的查找，时间复杂度为O(1);
对于一般的插入删除操作平均复杂度为O(n)

所以 数组的特点是查询快， 删除，新增慢

JAVA代码示例：

public static void main(String[] args){
 Integer [] array=new Integer[10];
 array[0]=0;

1.2.2 链表

链表是一种物理存储单元上非连续.非顺序的存储结构 数据元素的逻辑顺序是通过链表中的指针次序实现的
对于链表的新增 删除（在找到指定的位置时）时间复杂度为O(1)
查找操作时，复杂度为O（n）

所以 链表的新增和删除快 查找慢

JAVA代码

public class Node{
 private Object data;
 public Node next;public Node(Object data){
 this.data=data;
 }
 public static void main(String[] args){
 Node node=new Node(15);
 node.next=new Node(1);
 node.next.next=new Node(9):
 }

3.红黑树

定义：红黑树是一种自平衡的二叉查找树，是一种高效的查找树。红黑树有良好的效率，它可以在时间复杂度为O(logN)时间内完成查找 增加 删除等操作。

性质：

1.根是黑色

2.节点是红色或者黑色

3.所有的叶子都是黑色的（叶子是NIL节点）

4. 每个红色节点必须有两个黑色的子节点

5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点

有了上面的几个性质作为限制，即可避免二叉查找树退化成单链表的情况。但是，仅仅避免这种情况还不够，这里还要考虑某个节点到其每个叶子节点路径长度的问题。如果某些路径长度过长，那么，在对这些路径上的及诶单进行增删查操作时，效率也会大大降低。这个时候性质4和性质5用途就凸显了，有了这两个性质作为约束，即可保证任意节点到其每个叶子节点路径最长不会超过最短路径的2倍。原因如下：当某条路径最短时，这条路径必然都是由黑色节点构成。当某条路径长度最长时，这条路径必然是由红色和黑色节点相间构成（性质4限定了不能出现两个连续的红色节点）。而性质5又限定了从任一节点到其每个叶子节点的所有路径必须包含相同数量的黑色节点。此时，在路径最长的情况下，路径上红色节点数量 = 黑色节点数量。该路径长度为两倍黑色节点数量，也就是最短路径长度的2倍。举例说明一下，请看下图：

最短路径(1 条)： M----->E

最长路径(4条)：

M----->Q------>O------->N

M----->Q---->O----->P

M----->Y----->Y----->X

M----->Q----->Y---->Z

红黑树的操作：

1.红黑树的基本操作和其他树形结构一样，一般都包括查找、插入、删除等操作。前面说到，红黑树是一种自平衡的二叉查找树，既然是二叉查找树的一种，那么查找过程和二叉查找树一样，比较简单，这里不再赘述。

• 旋转操作
• 旋转操作分为左旋和右旋，左旋是将某个节点旋转为其右孩子的左孩子，而右旋是节点旋转为其左孩子的右孩子。这话听起来有点绕，所以还是请看下图：
  
  上图包含了左旋和右旋的示意图，这里以右旋为例进行说明，右旋节点 M 的步骤如下：

1.将节点 M 的左孩子引用指向节点 E 的右孩子
2.将节点 E 的右孩子引用指向节点 M，完成旋转

• *插入
• 红黑树的插入过程和二叉查找树插入过程基本类似，不同的地方在于，红黑树插入新节点后，需要进行调整，以满足红黑树的性质。性质1规定红黑树节点的颜色要么是红色要么是黑色，那么在插入新节点时，这个节点应该是红色还是黑色呢？答案是红色，原因也不难理解。如果插入的节点是黑色，那么这个节点所在路径比其他路径多出一个黑色节点，这个调整起来会比较麻烦（参考红黑树的删除操作，就知道为啥多一个或少一个黑色节点时，调整起来这么麻烦了）。如果插入的节点是红色，此时所有路径上的黑色节点数量不变，仅可能会出现两个连续的红色节点的情况。这种情况下，通过变色和旋转进行调整即可，比之前的简单多了。

接下来，将分析插入红色节点后红黑树的情况。这里假设要插入的节点为 N，N 的父节点为 P，祖父节点为 G，叔叔节点为 U。插入红色节点后，会出现5种情况，分别如下：

情况一

插入的新节点 N 是红黑树的根节点，这种情况下，我们把节点 N 的颜色由红色变为黑色，性质2（根是黑色）被满足。同时 N 被染成黑色后，红黑树所有路径上的黑色节点数量增加一个，性质5（从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点）仍然被满足。

情况二

N 的父节点是黑色，这种情况下，性质4（每个红色节点必须有两个黑色的子节点）和性质5没有受到影响，不需要调整。

情况三

N 的父节点是红色（节点 P 为红色，其父节点必然为黑色），叔叔节点 U 也是红色。由于 P 和 N 均为红色，所有性质4被打破，此时需要进行调整。这种情况下，先将 P 和 U 的颜色染成黑色，再将 G 的颜色染成红色。此时经过 G 的路径上的黑色节点数量不变，性质5仍然满足。但需要注意的是 G 被染成红色后，可能会和它的父节点形成连续的红色节点，此时需要递归向上调整。

情况四

N 的父节点为红色，叔叔节点为黑色。节点 N 是 P 的右孩子，且节点 P 是 G 的左孩子。此时先对节点 P 进行左旋，调整 N 与 P 的位置。接下来按照情况五进行处理，以恢复性质4。

情况五

N 的父节点为红色，叔叔节点为黑色。N 是 P 的左孩子，且节点 P 是 G 的左孩子。此时对 G 进行右旋，调整 P 和 G 的位置，并互换颜色。经过这样的调整后，性质4被恢复，同时也未破坏性质5。

插入总结

上面五种情况中，情况一和情况二比较简单，情况三、四、五稍复杂。但如果细心观察，会发现这三种情况的区别在于叔叔节点的颜色，如果叔叔节点为红色，直接变色即可。如果叔叔节点为黑色，则需要选选择，再交换颜色。当把这三种情况的图画在一起就区别就比较容易观察了，如下图：

• *删除
• 相较于插入操作，红黑树的删除操作则要更为复杂一些。删除操作首先要确定待删除节点有几个孩子，如果有两个孩子，不能直接删除该节点。而是要先找到该节点的前驱（该节点左子树中最大的节点）或者后继（该节点右子树中最小的节点），然后将前驱或者后继的值复制到要删除的节点中，最后再将前驱或后继删除。由于前驱和后继至多只有一个孩子节点，这样我们就把原来要删除的节点有两个孩子的问题转化为只有一个孩子节点的问题，问题被简化了一些。我们并不关心最终被删除的节点是否是我们开始想要删除的那个节点，只要节点里的值最终被删除就行了，至于树结构如何变化，这个并不重要。

红黑树删除操作的复杂度在于删除节点的颜色，当删除的节点是红色时，直接拿其孩子节点补空位即可。因为删除红色节点，性质5（从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点）仍能够被满足。当删除的节点是黑色时，那么所有经过该节点的路径上的黑节点数量少了一个，破坏了性质5。如果该节点的孩子为红色，直接拿孩子节点替换被删除的节点，并将孩子节点染成黑色，即可恢复性质5。但如果孩子节点为黑色，处理起来就要复杂的多。分为6种情况，下面会展开说明。

在展开说明之前，我们先做一些假设，方便说明。这里假设最终被删除的节点为X（至多只有一个孩子节点），其孩子节点为N，X的兄弟节点为S，S的左节点为 SL，右节点为 SR。接下来讨论是建立在节点 X 被删除，节点 N 替换X的基础上进行的。这里说明把被删除的节点X特地拎出来说一下的原因是防止大家误以为节点N会被删除，不然后面就会看不明白。

• 在上面的基础上，接下来就可以展开讨论了。红黑树删除有6种情况，分别是：
• 情况一
  N 是新的根。在这种情形下，我们就做完了。我们从所有路径去除了一个黑色节点，而新根是黑色的，所以性质都保持着。

上面是维基百科中关于红黑树删除的情况一说明，由于没有配图，看的有点晕。经过思考，我觉得可能会是下面这种情形：

要删除的节点 X 是根节点，且左右孩子节点均为空节点，此时将节点 X 用空节点替换完成删除操作。

可能还有其他情形，大家如果知道，烦请告知。
情况二
S 为红色，其他节点为黑色。这种情况下可以对 N 的父节点进行左旋操作，然后互换 P 与 S 颜色。但这并未结束，经过节点 P 和 N 的路径删除前有3个黑色节点（P -> X -> N），现在只剩两个了（P -> N）。比未经过 N 的路径少一个黑色节点，性质5仍不满足，还需要继续调整。不过此时可以按照情况四、五、六进行调整。

• 情况三
  N 的父节点，兄弟节点 S 和 S 的孩子节点均为黑色。这种情况下可以简单的把 S 染成红色，所有经过 S 的路径比之前少了一个黑色节点，这样经过 N 的路径和经过 S 的路径黑色节点数量一致了。但经过 P 的路径比不经过 P 的路径少一个黑色节点，此时需要从情况一开始对 P 进行平衡处理。
  *
  情况四
  N 的父节点为红色，叔叔节点为黑色。节点 N 是 P 的右孩子，且节点 P 是 G 的左孩子。此时先对节点 P 进行左旋，调整 N 与 P 的位置。接下来按照情况五进行处理，以恢复性质4。
  
  这里需要特别说明一下，上图中的节点 N 并非是新插入的节点。当 P 为红色时，P 有两个孩子节点，且孩子节点均为黑色，这样从 G 出发到各叶子节点路径上的黑色节点数量才能保持一致。既然 P 已经有两个孩子了，所以 N 不是新插入的节点。情况四是由以 N 为根节点的子树中插入了新节点，经过调整后，导致 N 被变为红色，进而导致了情况四的出现。考虑下面这种情况（PR 节点就是上图的 N 节点）：

如上图，插入节点 N 并按情况三处理。此时 PR 被染成了红色，与 P 节点形成了连续的红色节点，这个时候就需按情况四再次进行调整。

情况五

S 为黑色，S 的左孩子为红色，右孩子为黑色。N 的父节点颜色可红可黑，且 N 是 P 左孩子。这种情况下对 S 进行右旋操作，并互换 S 和 SL 的颜色。此时，所有路径上的黑色数量仍然相等，N 兄弟节点的由 S 变为了 SL，而 SL 的右孩子变为红色。接下来我们到情况六继续分析。

情况六

S 为黑色，S 的右孩子为红色。N 的父节点颜色可红可黑，且 N 是其父节点左孩子。这种情况下，我们对 P 进行左旋操作，并互换 P 和 S 的颜色，并将 SR 变为黑色。因为 P 变为黑色，所以经过 N 的路径多了一个黑色节点，经过 N 的路径上的黑色节点与删除前的数量一致。对于不经过 N 的路径，则有以下两种情况：该路径经过 N 新的兄弟节点 SL ，那它之前必然经过 S 和 P。而 S 和 P 现在只是交换颜色，对于经过 SL 的路径不影响。

该路径经过 N 新的叔叔节点 SR，那它之前必然经过 P、 S 和 SR，而现在它只经过 S 和 SR。在对 P 进行左旋，并与 S 换色后，经过 SR 的路径少了一个黑色节点，性质5被打破。另外，由于 S 的颜色可红可黑，如果 S 是红色的话，会与 SR 形成连续的红色节点，打破性质4（每个红色节点必须有两个黑色的子节点）。此时仅需将 SR 由红色变为黑色即可同时恢复性质4和性质5（从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。）。

删除总结

红黑树删除的情况比较多，大家刚开始看的时候可能会比较晕。可能会产生这样的疑问，为啥红黑树会有这种删除情况，为啥又会有另一种情况，它们之间有什么联系和区别？和大家一样，我刚开始看的时候也有这样的困惑，直到我把所有情况对应的图形画在一起时，拨云见日，一切都明了了。此时天空中出现了4个字，原来如此、原来如此、原来如此。所以，请看图吧：

总结

红黑树是一种重要的二叉树，应用广泛，但在很多数据结构相关的书本中出现的次数并不多。很多书中要么不说，要么就一笔带过，并不会进行详细的分析，这可能是因为红黑树比较复杂的缘故。本人在学习红黑树的时候也找了很多资料，但总体感觉讲的都不太好。尤其是在我学习删除操作的时候，很多资料是实在人看不下去，看的我很痛苦

1.3HashMap算法(使用链地址法)

Hash 一般称之为散列 就是把任意长度的输入通过散列算法，变换成固定长度的输出，这个输出就是哈希值，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HashMap中通常是使用分离链接散列地址法实现的。

假设关键字是前10个完全平方数并设散列函数是hash(x)= x mod 10

static final int hash(Object key) {
 int h;
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右移16位进行异或运算（高低位异或）
 }

问题：.使用hash 会出现哈希冲突

解决措施：

1.使用链地址法

2. 使用2次扰动函数（hash函数）来降低哈希冲突的概率，使得数据分布更平均

3. 引入红黑树进一步降低遍历的时间复杂度，使得遍历更快

二 hashMap的源码分析

1.属性

初始化容量（必须是2的n次幂）

负载因子（默认的是 0.75）

当链表的值超过8会转化为红黑树

当链表的值小于6 会从红黑树转回链表

table 用来初始化

用来存放缓存

HashMap中存储的数量

用来记录HashMap的修改次数

用来调整大小 下一个容量的值计算方式为（容量* 负载因子）

哈希表的加载因子

table在JDK1.8中我们了解到HashMap是由数组加链表加红黑树来组成的结构其中table就是HashMap中的数组

• size为HashMap中K-V的实时数量
• loadFactor加载因子，是用来衡量 HashMap 满的程度，计算HashMap的实时加载因子的方法为：size/capacity，而不是占用桶的数量去除以capacity。capacity 是桶的数量，也就是 table 的长度length。
  *threshold计算公式：capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容)，扩容后的 HashMap 容量是之前容量的两倍
  2.方法
  2.1构造方法
  1.HashMap() 构造一个空的HashMap，默认初始容量是16 和默认负载因子 （0.75）

2. HashMap(int initialCapacity)
   
   3.HashMap(int initialCapacity, float loadFactor)
   构造一个空的 HashMap具有指定的初始容量和负载因子。我们来分析一下。
   
   最后调用了tableSizeFor
   
   threshold=capacity*loadFactor

2.2 put()方法

public V put(K key, V value) {
 return putVal(hash(key), key, value, false, true);
 }
static final int hash(Object key) {
 int h;
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

//实现Map.put和相关方法
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 boolean evict) {
 Node<K,V>[] tab; Node<K,V> p; int n, i;
 // 步骤①：tab为空则创建
 // table未初始化或者长度为0，进行扩容
 if ((tab = table) == null || (n = tab.length) == 0)
 n = (tab = resize()).length;
 // 步骤②：计算index，并对null做处理
 // (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;
 // 步骤③：节点key存在，直接覆盖value
 // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
 if (p.hash == hash &&
 ((k = p.key) == key || (key != null && key.equals(k))))
 // 将第一个元素赋值给e，用e来记录
 e = p;
 // 步骤④：判断该链为红黑树
 // hash值不相等，即key不相等；为红黑树结点
 // 如果当前元素类型为TreeNode，表示为红黑树，putTreeVal返回待存放的node, e可能为null
 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
                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值、key值时，返回新来的value这个值
    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;

2.3 resize()方法
HashMap通过负载因子（Load Factor）乘以buckets数组的长度来计算出临界值，算法：threshold = load_factor * capacity。比如，HashMap的默认初始容量为16（capacity = 16），默认负载因子为0.75（load_factor = 0.75），那么临界值就为threshold = 0.75 * 16 = 12，只要Entry的数量大于12，就会触发扩容操作。

final Node<K,V>[] resize() {
 Node<K,V>[] oldTab = table;//oldTab指向hash桶数组
 int oldCap = (oldTab == null) ? 0 : oldTab.length;
 int oldThr = threshold;
 int newCap, newThr = 0;
 if (oldCap > 0) {//如果oldCap不为空的话，就是hash桶数组不为空
 if (oldCap >= MAXIMUM_CAPACITY) {//如果大于最大容量了，就赋值为整数最大的阀值
 threshold = Integer.MAX_VALUE;
 return oldTab;//返回
 }//如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16
 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
 oldCap >= DEFAULT_INITIAL_CAPACITY)
 newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold
 }
 // 旧的容量为0，但threshold大于零，代表有参构造有cap传入，threshold已经被初始化成最小2的n次幂
 // 直接将该值赋给新的容量
 else if (oldThr > 0) // initial capacity was placed in threshold
 newCap = oldThr;
 // 无参构造创建的map，给出默认容量和threshold 16, 16*0.75
 else { // zero initial threshold signifies using defaults
 newCap = DEFAULT_INITIAL_CAPACITY;
 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
 }
 // 新的threshold = 新的cap * 0.75
 if (newThr == 0) {
 float ft = (float)newCap * loadFactor;
 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
 (int)ft : Integer.MAX_VALUE);
 }
 threshold = newThr;
 // 计算出新的数组长度后赋给当前成员变量table
 @SuppressWarnings({“rawtypes”,“unchecked”})
 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//新建hash桶数组
 table = newTab;//将新数组的值复制给旧的hash桶数组
 // 如果原先的数组没有初始化，那么resize的初始化工作到此结束，否则进入扩容元素重排逻辑，使其均匀的分散
 if (oldTab != null) {
 // 遍历新数组的所有桶下标
 for (int j = 0; j < oldCap; ++j) {
 Node<K,V> e;
 if ((e = oldTab[j]) != null) {
 // 旧数组的桶下标赋给临时变量e，并且解除旧数组中的引用，否则就数组无法被GC回收
 oldTab[j] = null;
 // 如果e.next==null，代表桶中就一个元素，不存在链表或者红黑树
 if (e.next == null)
 // 用同样的hash映射算法把该元素加入新的数组
 newTab[e.hash & (newCap - 1)] = e;
 // 如果e是TreeNode并且e.next!=null，那么处理树中元素的重排
 else if (e instanceof TreeNode)
 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
 // e是链表的头并且e.next!=null，那么处理链表中元素重排
 else { // preserve order
 // loHead,loTail 代表扩容后不用变换下标，见注1
 Node<K,V> loHead = null, loTail = null;
 // hiHead,hiTail 代表扩容后变换下标，见注1
 Node<K,V> hiHead = null, hiTail = null;
 Node<K,V> next;
 // 遍历链表
 do {
 next = e.next;
 if ((e.hash & oldCap) == 0) {
 if (loTail == null)
 // 初始化head指向链表当前元素e，e不一定是链表的第一个元素，初始化后loHead
 // 代表下标保持不变的链表的头元素
 loHead = e;
 else
 // loTail.next指向当前e
 loTail.next = e;
 // loTail指向当前的元素e
 // 初始化后，loTail和loHead指向相同的内存，所以当loTail.next指向下一个元素时，
 // 底层数组中的元素的next引用也相应发生变化，造成lowHead.next.next…
 // 跟随loTail同步，使得lowHead可以链接到所有属于该链表的元素。
 loTail = e;
 }
 else {
 if (hiTail == null)
 // 初始化head指向链表当前元素e, 初始化后hiHead代表下标更改的链表头元素
 hiHead = e;
 else
 hiTail.next = e;
 hiTail = e;
 }
 } while ((e = next) != null);
 // 遍历结束, 将tail指向null，并把链表头放入新数组的相应下标，形成新的映射。
 if (loTail != null) {
 loTail.next = null;
 newTab[j] = loHead;
 }
 if (hiTail != null) {
 hiTail.next = null;
 newTab[j + oldCap] = hiHead;
 }
 }
 }
 }
 }
 return newTab;
 }

HashMap的扩容操作
①.在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容；

②.每次扩展的时候，都是扩展2倍；

③.扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。

在putVal()中，我们看到在这个函数里面使用到了2次resize()方法，resize()方法表示的在进行第一次初始化时会对其进行扩容，或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发，这也是JDK1.8版本的一个优化的地方，在1.7中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发，但在1.8版本中，则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上