Android 面试准备之「equals 和 == 」

本文为原创文章，如需转载请注明出处，谢谢!

概述

本文将围绕以下五点进行说明

1.equals() 和 == 的作用以及应用
2.hashCode() 的作用及应用
3.hashCode() 和 equals() 的联系
4.HashSet 和 HashMap 的特性
5.Hash 冲突是什么以及如何解决

一、equals() 和 == 的区别

废话不多说，先举个栗子！

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1.equals(str2));
System.out.println(str1 == str2);

许多 Java 基础笔试题中都会出现类似的题目，其实就是在考察是否理解 equals() 和 == 的本质区别。我们先把结论说一下：

1. equals() 方法比较的是两个对象是否相等。

2. == 分为两种情况

  • 比较对象，比较的是对象在内存中的空间地址是否相等
  • 比较基本类型，比较的是值是否相等

解释完原理后，相信上面的题解答就易如反掌了，str1,str2 均为 String 对象。equals() 比较对象，== 比较内存地址，那么问题来了，String 的 equals()方法是怎么比较对象是否相等的呢？那我们就来看看源码吧

public boolean equals(Object anObject) {
        if (this == anObject) { //对象的空间地址相同，说白了就是一个对象！
            return true;
        }
        if (anObject instanceof String) { //地址不同，而且对象是 String
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) { 
            //这里首先看两个 String 长度是否相同，如果不同就不等
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { //然后逐一比对字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }// 所有字符都相等，OK ,String对象就相等了
                return true;
            }
        }
        return false;
    }

经过源码（真理）的一番解释，我们明白了 String 的 equals()的比较逻辑，所以第一个打印为 true。第二个打印比较的是 str1 和 str2 两个引用指向 new 的对象的地址，明显不同，所以为 false。

补充：上面我们分析了 String 的 equals() 方法，那么平时我们使用自定义对象时，equals 又有什么作用呢？我们都知道 Java 中所有的类都继承自 Object，所以我们需要看一下 Object 的 equals() 做了什么。

public boolean equals(Object obj) {
    return (this == obj);
}

可以看到 equals() 实际上就是用 == 来比较两个对象是否相等。所以我们可以得出如下结论：

  • 如果不重写 equals() ，则 equals() 和 == 效果相同，比较的都是对象内存地址是否相同
  • 重写 equals() ，则根据 equals 内的逻辑判断两个对象是否相同

二、equals() 和 hashCode() 的关系

可能一说到 hashCode() 方法，就能开始背课文了：
1、如果两个对象相等（equals() 返回 true），那么它们的 hashCode()一定要相同；
2、如果两个对象hashCode()相等，它们并不一定相等（equals() 不一定返回 true）。

这课文的结论肯定没错，但他们的应用场景究竟是什么呢？我们什么时候会同时用到 equals()和 hashCode() 呢？

在回答这两个问题前，我们先要认清 hashCode()方法的作用是什么，来看下面的解释。

hashCode()，返回对象的哈希码，作用是根据哈希码确定对象在散列表中的位置（单独创建对象或创建数组类型对象时 hashCode() 无作用)。

上面的解释已经很清晰了，那么问题来了，散列表又是啥？再来看看散列表的解释。

散列表本质是数组存储，通过 key-value 的形式存储数据，所以当取 value 的时候，实际上取数组某个位置的元素，并且以 key 的 hashCode 作为 value 在数组中的位置。

我们平时用的 HashSet、HashMap 都是散列表结构，接着我们就以这两个集合为例，详细分析一下 hashCode 在其中的作用。

我们先在此小节简单的说一下 HashSet。面试题常会问，List 和 Set 的区别是什么，又可以背课文了：

1.List 是按 add 顺序存储，且元素可以重复，元素有索引，可以根据元素位置进行 get。
2.Set 存储元素无序，元素不可重复，没有 get 方法，只能通过迭代器获取元素。

我们来逐一解释一下 Set 的特性：

  • 元素无序：上文已经说散列表其实是数组结构，元素的位置是hashCode 决定的，所以元素的顺序我们无法确定。

  • 元素不可重复：这个特性其实由 HashMap 决定，what？你没看错，就是 HashMap，我们看一下 HashSet 的 add 方法就明白了。

    private transient HashMap<E,Object> map;

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

    我们看到其实 Set 中的元素就是 HashMap 中的 KeySet 中的元素，而每个 Key 对应的 Value 都是一个新的 Object 对象，我们又知道 HashMap 中不允许 key 值重复，所以 Set 中的元素也不会重复，至于原理我们在后面一节单讲 HashMap 的时候再说。

  • 没有 get：元素位置本身是由元素的 hashCode 决定，而我们无法事先获取 hashCode 然后再去获取元素，这是一个不可逆的过程。

说了这么多好像有些偏离本节题目了！不好意思，哈哈，马上回到正轨！那么本节开始时背的课文到底说的是什么情况呢，看看我发现的几个好栗子吧！

以下内容均出自 http://www.cnblogs.com/skywang12345/p/3324958.html

 1 import java.util.*;
 2 import java.lang.Comparable;
 3 
 4 /**
 5  * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
 6  *
 7  * @author skywang
 8  * @emai kuiwu-wang@163.com
 9  */
10 public class ConflictHashCodeTest1{
11 
12     public static void main(String[] args) {
13         // 新建Person对象，
14         Person p1 = new Person("eee", 100);
15         Person p2 = new Person("eee", 100);
16         Person p3 = new Person("aaa", 200);
17 
18         // 新建HashSet对象 
19         HashSet set = new HashSet();
20         set.add(p1);
21         set.add(p2);
22         set.add(p3);
23 
24         // 比较p1 和 p2， 并打印它们的hashCode()
25         System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
26         // 打印set
27         System.out.printf("set:%s\n", set);
28     }
29 
30     /**
31      * @desc Person类。
32      */
33     private static class Person {
34         int age;
35         String name;
36 
37         public Person(String name, int age) {
38             this.name = name;
39             this.age = age;
40         }
41 
42         public String toString() {
43             return "("+name + ", " +age+")";
44         }
45 
46         /** 
47          * @desc 覆盖equals方法 
48          */  
49         @Override
50         public boolean equals(Object obj){  
51             if(obj == null){  
52                 return false;  
53             }  
54               
55             //如果是同一个对象返回true，反之返回false  
56             if(this == obj){  
57                 return true;  
58             }  
59               
60             //判断是否类型相同  
61             if(this.getClass() != obj.getClass()){  
62                 return false;  
63             }  
64               
65             Person person = (Person)obj;  
66             return name.equals(person.name) && age==person.age;  
67         } 
68     }
69 }

运行结果

p1.equals(p2) : true; p1(1169863946) p2(1690552137)
set:[(eee, 100), (eee, 100), (aaa, 200)]

我们重写了Person的equals()。但是，很奇怪的发现：HashSet中仍然有重复元素：p1 和 p2。为什么会出现这种情况呢？这是因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。

接下来我们同时重写 equals 和 hashCode。

 1 import java.util.*;
 2 import java.lang.Comparable;
 3 
 4 /**
 5  * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
 6  *
 7  * @author skywang
 8  * @emai kuiwu-wang@163.com
 9  */
10 public class ConflictHashCodeTest2{
11 
12     public static void main(String[] args) {
13         // 新建Person对象，
14         Person p1 = new Person("eee", 100);
15         Person p2 = new Person("eee", 100);
16         Person p3 = new Person("aaa", 200);
17         Person p4 = new Person("EEE", 100);
18 
19         // 新建HashSet对象 
20         HashSet set = new HashSet();
21         set.add(p1);
22         set.add(p2);
23         set.add(p3);
24 
25         // 比较p1 和 p2， 并打印它们的hashCode()
26         System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
27         // 比较p1 和 p4， 并打印它们的hashCode()
28         System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
29         // 打印set
30         System.out.printf("set:%s\n", set);
31     }
32 
33     /**
34      * @desc Person类。
35      */
36     private static class Person {
37         int age;
38         String name;
39 
40         public Person(String name, int age) {
41             this.name = name;
42             this.age = age;
43         }
44 
45         public String toString() {
46             return name + " - " +age;
47         }
48 
49         /** 
50          * @desc重写hashCode 
51          */  
52         @Override
53         public int hashCode(){  
54             int nameHash =  name.toUpperCase().hashCode();
55             return nameHash ^ age;
56         }
57 
58         /** 
59          * @desc 覆盖equals方法 
60          */  
61         @Override
62         public boolean equals(Object obj){  
63             if(obj == null){  
64                 return false;  
65             }  
66               
67             //如果是同一个对象返回true，反之返回false  
68             if(this == obj){  
69                 return true;  
70             }  
71               
72             //判断是否类型相同  
73             if(this.getClass() != obj.getClass()){  
74                 return false;  
75             }  
76               
77             Person person = (Person)obj;  
78             return name.equals(person.name) && age==person.age;  
79         } 
80     }
81 }

运行结果

p1.equals(p2) : true; p1(68545) p2(68545)
p1.equals(p4) : false; p1(68545) p4(68545)
set:[aaa - 200, eee - 100]

这下，equals() 生效了，HashSet中没有重复元素。比较p1和p2，我们发现：它们的 hashCode() 相等，通过equals()比较它们也返回true。所以，p1和p2被视为相等。比较p1和p4，我们发现：虽然它们的hashCode()相等；但是，通过 equals() 比较它们返回false。所以，p1和p4被视为不相等。

小结

  1. 在单独使用对象的时候，hashCode() 对于对象判等没有作用。
  2. 在散列表中使用对象，一定要同时重写 hashCode() 和 equals()，并且要保证 hashCode() 的算法能尽量保证对象的唯一。
  3. HashSet 会先去判断对象的 hashCode 相不相等，如果不相等对象一定不等，如果相等再去通过 equals() 判断对象是否相等。
  4. 本节开始背的课文其实就是针对使用散列表存储对象的时候，我们应该如何设计对象的 equals() 和 hashCode()。

三、HashMap 简析源码

上一节分析 HashSet 时，我们看到 HashSet 内部其实维护了一个 HashMap 对象，add() 实际上是调用 map.put(e, PRESENT)，所以我们直接看一下 put(key, value) 都做了些什么。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
    //通过 hash 方法计算 key 的 hash 值
}

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)
    //tab 就是存放键值对(Node)的数组，如果 tab 为 null 则去初始化 tab
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
    //通过 hash 计算 index，如果计算位置的 Node 为 null，则新创建一个 Node
        tab[i] = newNode(hash, key, value, null);
    else {
    //当前位置存在 Node
        Node<K,V> e; K k;
        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);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

1.可以看到 tab 是 Node 类型的数组结构，Node 是负责管理 Key 和 Value 的节点类型，我们就明白了 HashMap 是用一个个节点来帮助我们存储键值对的，并将节点保存在了数组中。方法中最开始就是去判空和初始化 tab 的过程，已有注释标注。

2.根据 key 的 hash 值来计算数组的位置 index，然后对当前位置的节点判空，如果为 null，则新建一个节点对象。

3.若 tab[index] != null，则需要对比当前节点（后文用 curNode 表示）和 put 进来的节点（后文用 putNode 表示）是否相同。可以看到源码中用两个条件进行判断:

  • 首先比较 curNode 和 putNode 的 hash 值是否相同（Node 的 hash 即为 key 的 hash），如果 hash 值不同，则两个对象一定不等，两个 hash 等，但对象不一定等（发生了 hash 冲突，我将在下一节详细说解决 hash 冲突的办法），如果 hash 值等，则进入下一个条件。

  • 此条件里先比较 curNode.key == putNode.key，也就是直接比较引用的内存地址，如果相同则对象相等，如果两个 key 的引用不同，则继续比较curNode.key.equals(putNode.key)，前提是 putNode.key != null，引用不同则通过 equals 方法来比较两个对象是否相同，有没有似曾相识的感觉，正是我们重写 equals 方法时的思路。

  • 一路判断下来，如果条件都为真，直接进行了赋值操作，即向 HashMap 中 put key 值相同的键值对时，value 会覆盖之前的 value。

4.假若 3 中的判断条件为假，即两个对象 hash 值相等，对象却不等，便发生了 hash 冲突，我们先看看 HashMap 是怎么解决冲突的。我在代码注释中已经写到「红黑树」和「单链表」进行存储冲突的节点，为什么是两种方式呢？我们都知道单链表的查询效率并不高，所以当冲突节点 >= TREEIFY_THRESHOLD(8) 时，会调用 treeifyBin() 把单链表转为树，这样之后在 get 的时候效率会提高。这种通过链表结构解决 hash 冲突的方法称为「链地址法」。

5.解决冲突后面的代码就是一些将 value 写入的过程，再之后就是处理数组容量的代码，我没细分析这里，如果同学有兴趣的话再自己钻研一下吧~

分析了这么多 put 的原理，相信 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) {
            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;
}

1.如果 tab 内有对象，直接取 tab[hash(key)] 这个节点（第一个），源码中有注释 「always check first node」,如果经过 hash 值判断， == 判断，equals 判断后都通过，则直接返回 first 节点，也就是我们通过 key 取到的节点。

2.如果 first 节点不是我们要的，而 first 后面还继续接有其他节点，那么就会遍历后面的节点通过 key.hash 以及 key.equals 找到我们想要的节点然后再返回即可。

充分理解了 put 的原理后，get 很容易就理解了~以后面试官问到懂不懂 HashMap 的原理的时候，可以好好地装一个x了~ 最后，推荐给大家一篇讲HashMap 原理极其细致的文章
http://yikun.github.io/2015/04/01/Java-HashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/#1-_%E6%A6%82%E8%BF%B0

四、Hash 冲突

hash 算法不是万能的，不可能保证每个元素的 hash 值不一样，所以在用散列表存储数据时难免会遇到两个不同的元素却拥有着相同的 hashCode，这样便造成了 hash 冲突。

解决方法有四种，我就用通俗一点的话来阐述一下：

  • 开放定址法：
    既然当前位置容不下冲突的元素了，那就再找一个空的位置存储 Hash 冲突的值（当前 index 冲突了，那么将冲突的元素放在 index+1)。

  • 再散列法：
    换一个 Hash 算法再计算一个 hash 值，如果不冲突了就存储值（例如第一个算法是名字的首字母的 Hash 值，如果冲突了，计算名字的第二个字母的 Hash 值，如果冲突解决了则将值放入数组中）。

  • 链地址法：
    每个数组中都存有一个单链表，发生 Hash 冲突时，只是将冲突的 value 当作新节点插入到链表（HashMap 解决冲突的办法）。

  • 公共溢出区法：
    将冲突的 value 都存到另外一个顺序表中，查找时如果当前表没有对应值，则去溢出区进行顺序查找。

总结

equals() 和 == 加上 hashCode 其实涉及了很多的基础知识，真的需要我们细细的总结，也许哪一个小的细节就会成为我们面试时的亮点，之后我可能还会继续总结一些针对面试 java 基础相关的知识，欢迎大家继续收看~

我也是个初学者，如写的有问题，请及时联系我！感谢！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,324评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,303评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,192评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,555评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,569评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,566评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,927评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,583评论 0赞 257
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,827评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,590评论 2赞 320
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,669评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,365评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,941评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,928评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,159评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,880评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,399评论 2赞 342

推荐阅读更多精彩内容

  • 面试知识点1
    Java8张图 11、字符串不变性 12、equals()方法、hashCode()方法的区别 13、...
    Miley_MOJIE阅读 3,690评论 0赞 11
  • Android 面试之 Java 篇二
    本文出自 Eddy Wiki ，转载请注明出处：http://eddy.wiki/interview-java.h...
    eddy_wiki阅读 1,151评论 0赞 16
  • HashMap的实现
    实际上，HashSet 和 HashMap 之间有很多相似之处，对于 HashSet 而言，系统采用 Hash 算...
    曹振华阅读 2,507评论 1赞 37
  • 纯干货！JAVA细节标注+源码分析
    一、基本数据类型 注释 单行注释：// 区域注释：/* */ 文档注释：/** */ 数值 对于byte类型而言...
    龙猫小爷阅读 4,253评论 0赞 16
  • 西北行诗一首
    我看见高山峡谷，阡陌良田； 看见湖光山色，一望无垠； 戈壁草原，沙漠清泉。 我看见金阁白塔，僧侣经幡； 看见丝绫堆...
    SpongeMel阅读 506评论 4赞 3