精华内容
下载资源
问答
  • 1、首先我们看看对象默认的(Object)的equals方法和hashcode方法public booleanequals...对象在不重写的情况下使用的是Object的equals方法和hashcode方法,从Object类的源码我们知道,默认的equals 判断的是两个对...

    1、首先我们看看对象默认的(Object)的equals方法和hashcode方法

    public booleanequals(Object obj) {
    return(this== obj);
    }
    public native inthashCode();

    对象在不重写的情况下使用的是Object的equals方法和hashcode方法,从Object类的源码我们知道,默认的equals 判断的是两个对象的引用指向的是不是同一个对象;而hashcode也是根据对象地址生成一个整数数值;

    c122aad5c22583ea8596a6c725432508.png

    2、重写equals

    案例场景:

    定义一个User对象有多个属性值姓名、年龄、身份证;

    我们写代码的时候会发现,两个new 出来的User()对象 无论他们的的各项值是否一样两个对象equals 永远都是false,两个对象值完全一样放到HashSet里面它会把这两个值完全一样的对象当成两个不同的对象了,这样的话好像HashSet的特性就丢失了;

    其实原因就是我们没有重写User 的equals方法,它会调用Object的equals方法,就如上图一样,Object的equals方法是比较对象的引用对象是否是同一个,两个new出来的对象当然不一样。

    好了现在需求来了,我们需要两个对象的各项属性值一样的就认为这两个对象是相等的;那么此时我们就需要重写equals方法了;

    代码如下:

    public classUser {
    privateStringname;//姓名
    privateStringIdCard;//身份证
    private intage;//年龄
    /**
    * 重写equals
    *@paramobj
    *@return
    */
    @Override
    public boolean equals(Object obj) {
     if (obj instanceof User) {
            User user = (User) obj;
     if (user.getIdCard().equals(this.IdCard) && user.getName().equals(this.name) &&      user.getAge() == this.age) {
     return true;
            } else {
     return false;
            }
        } else {
     return false;
        }
    }
    //......省略N行代码
    }

    那么现在关键的地方来了:现在我们重写了User对象的equals方法,但并没有重写hashcode方法。

    (1)首先测试下equals的正确性

    User user1=newUser();
    user1.setName("路西");
    user1.setAge(18);
    user1.setIdCard("430");
    User user2=newUser();
    user2.setName("路西");
    user2.setAge(18);
    user2.setIdCard("430");
    System.out.println("user1.equals(user2)="+user1.equals(user2));
    user1.equals(user2)测试结果为true;

    (2)在两个对象equals的情况下进行把他们分别放入Map和Set中

    在上面的代码基础上追加如下代码:

    Set set =newHashSet();
    set.add(user1);
    set.add(user2);
    Map map=newHashMap();
    map.put(user1,"user1");
    map.put(user2,"user2");
    System.out.println("set 长度"+set.size());
    System.out.println("map 长度"+map.keySet().size());;

    测试打印结果为:

    ac3656f3f4baa7d19a8bafb2565bae8e.png

    好了现在问题来了,明明user1和user2两个对象是equals的那么为什么把他们放到set中会有两个对象(Set特性是不允许重复数据的),还有Map也把两个同样的对象当成了不同的Key(Map的Key是不允许重复的,相同Key会覆盖);

    (3)这里我先抛出结果,至于原理后面再进行描述

    原因是user1和user2的hashcode 不一样导致的;

    6f8cb3f705e81857117ef4314f58ff37.png

    因为我们没有重写父类(Object)的hashcode方法,Object的hashcode方法会根据两个对象的地址生成对相应的hashcode;

    user1和user2是分别new出来的,那么他们的地址肯定是不一样的,自然hashcode值也会不一样。

    Set区别对象是不是唯一的标准是,两个对象hashcode是不是一样,再判定两个对象是否equals;

    Map 是先根据Key值的hashcode分配和获取对象保存数组下标的,然后再根据equals区分唯一值(详见下面的map分析)

    3、重写hashcode方法;

    public classUser  {
    privateStringname;//姓名
    privateStringIdCard;//身份证
    private intage;//年龄
    /**
    * 重写equals
    *@paramobj
    *@return
    */
    @Override
    public boolean equals(Object obj) {
     if (obj instanceof User) {
            User user = (User) obj;
     if (user.getIdCard().equals(this.IdCard) && user.getName().equals(this.name) && user.getAge() == this.age) {
     return true;
            } else {
     return false;
            }
        } else {
     return false;
        }
    }
    
    @Override
    public int hashCode() {
     int result = name.hashCode();
        result = 31 * result + IdCard.hashCode();
        result = 31 * result + age;
     return result;
    }
    //......省略N行代码
    }

    我们按之前的流程重新测试一遍结果:

    User user1=newUser();
    user1.setName("路西");
    user1.setAge(18);
    user1.setIdCard("430");
    User user2=newUser();
    user2.setName("路西");
    user2.setAge(18);
    user2.setIdCard("430");
    System.out.println("user1.equals(user2)="+user1.equals(user2));
    Set set =newHashSet();
    set.add(user1);
    set.add(user2);
    Map map=newHashMap();
    map.put(user1,"user1");
    map.put(user2,"user2");
    System.out.println("set 长度"+set.size());
    System.out.println("map 长度"+map.keySet().size());;
    System.out.println("user1的hashcode"+user1.hashCode());
    System.out.println("user2的hashcode"+user2.hashCode());

    打印结果:

    8474172bf81bb0addb76008f26129c3f.png

    4、补充HashMap知识

    hashMap组成结构:hashMap是由数组和链表组成;

    hashMap的存储:一个对象存储到hashMap中的位置是由其key 的hashcode值决定的;查hashMap查找key: 找key的时候hashMap会先根据key值的hashcode经过取余算法定位其所在数组的位置,再根据key的equals方法匹配相同key值获取对应相应的对象;

    案例:

    (1)hashmap存储

    存值规则:把Key的hashCode 与HashMap的容量 取余得出该Key存储在数组所在位置的下标(源码定位Key存储在数组的哪个位置是以hashCode & (HashMap容量-1)算法得出)这里为方便理解使用此方式;

    //为了演示方便定义一个容量大小为3的hashMap(其默认为16)

    HashMap map=newHashMap(3);

    map.put("a",1); 得到key 为“a” 的hashcode 值为97然后根据 该值和hashMap 容量取余97%3得到存储位到数组下标为1;

    map.put("b",2); 得到key 为“b” 的hashcode 值为98,98%3到存储位到数组下标为2;

    map.put("c",3); 得到key 为“c” 的hashcode 值为99,99%3到存储位到数组下标为0;

    map.put("d",4); 得到key 为“d” 的hashcode 值为100,100%3到存储位到数组下标为1;

    map.put("e",5); 得到key 为“e” 的hashcode 值为101,101%3到存储位到数组下标为2;

    map.put("f",6); 得到key 为“f” 的hashcode 值为102,102%3到存储位到数组下标为0;

    6f5d11d887cc024532e2cb706454b20f.png

    (2)hashmap的查找key

    得到key在数组中的位置:根据上图,当我们获取key 为“a”的对象时,那么我们首先获得 key的hashcode97%3得到存储位到数组下标为1;

    匹配得到对应key值对象:得到数组下表为1的数据“a”和“c”对象, 然后再根据 key.equals()来匹配获取对应key的数据对象;

    hashcode 对于HashMapde:如果没有hashcode 就意味着HashMap存储的时候是没有规律可寻的,那么每当我们map.get()方法的时候,就要把map里面的对象一一拿出来进行equals匹配,这样效率是不是会超级慢;

    5、hashcode方法文档说明

    在equals方法没被修改的前提下,多次调用同一对象的hashcode方法返回的值必须是相同的整数;

    如果两个对象互相equals,那么这两个对象的hashcode值必须相等;

    为不同对象生成不同的hashcode可以提升哈希表的性能;

    展开全文
  • 在学习集合中,HashMap/HashSet是非常常用的集合,但是在使用时刻要想着重写equals方法和hashCode方法,所以在这里简单说一说在使用HashMap或者HashSet中为什么必须要重写equals方法和hashCode方法, 在介绍之前先...

    引言

    在学习集合中,HashMap/HashSet是非常常用的集合,但是在使用时刻要想着重写equals方法和hashCode方法,所以在这里简单说一说在使用HashMap或者HashSet中为什么必须要重写equals方法和hashCode方法,

    在介绍之前先简单介绍一下一种数据结构——哈希表,如果不理解这个数据结构,那么不利于对重写原因的理解的;

    哈希表

    基本思想: 记录的存储位置关键字之间存在对应关系,Loc(i)=H(keyi) (注:这是一个哈希函数)

    优点: 查找速度极快O(1),查找效率与元素个数n无关

    注:略去部分内容,只看本文需要的内容;
    哈希表的一种存储方法(处理冲突的方法)叫做:链地址法,下面也围绕这个方法展开的

    基本思想相同哈希地址的记录链成一单链表,m个哈希地址就设m个单链表,然后用用一个数组将m个单链表的表头指针存储起来,形成一个动态的结构;(一定要理解这句话!!!)
    在这里插入图片描述
    就像这样子,每一个哈希地址对应一个单链表,每个单链表上的每个key值对应一个value值;所以看哈希表就像一个数组和多个链表的合体;

    先有个大致印象,下面我们看看HashMap的结构
    !]
    解释一下:哈希地址就类似数组下标,在图中用hash表示,HashMap中的key值就是k,Vaule值就是v;

    当我们往HashMap中存储数据时,先通过hash确定到某一条链表上,然后再通过key值在链表中进行比较,如果没有相同的key值的话,就在最后新创建一个节点把Value值v放进去,如果有相等的key值,那么新的v会覆盖之前的v

    那么hash值是从哪来的呢?
    hash值就是key的hashCode的返回值;
    有了hash值后key值比较的过程就是使用equals方法;

    能看出来为什么要重写hashCode方法和equals方法了吗?
    就是因为每一个对象的hashCode值都不相同,而不同的对象使用equals方法比较的只是内存地址,而内存地址也不相同;
    我们想要的结果只是 相同内容的hashCode值相同,相同内容的比较相同!
    所以我们要针对我们的对象内容重写hashCode方法和equals方法;

    下面通过例子更形象的说明:

    实例说明

    这里我自定义了一个User类,并没有重写HashCode和equals;
    我们先看看有相同内容的对象的HashCode值是否相同:

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    
    public class MapTest05 {
        public static void main(String[] args) {
            Map<User, String> map = new HashMap<>();
            // 创建四个User对象
            User u1 = new User("张三", 18);
            User u2 = new User("李四", 20);
            User u3 = new User("王五", 30);
            User u4 = new User("王五", 30); // 创建一个和u3内容一样的对象u4
    
            // 先看看hashCode值
            System.out.println("u1的hashCode值为:" + u1.hashCode());
            System.out.println("u2的hashCode值为:" + u2.hashCode());
            System.out.println("u3的hashCode值为:" + u3.hashCode());
            System.out.println("u4的hashCode值为:" + u4.hashCode());
        }
    }
    // 用户类
    class User {
        private String name; // 姓名
        private int age; // 年龄
    
        // 默认构造
        User() {}
        // 有参构造
        User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // equals方法未重写
        // hashcode方法未重写
    }
    

    输出结果:

    u1的hashCode值为:2003749087
    u2的hashCode值为:1480010240
    u3的hashCode值为:81628611
    u4的hashCode值为:1828972342
    

    可以看到,每一个对象的hashCode值都不同,尤其注意u3和u4内容相同而hashCode值不同;
    接下来把它们放到map中看看会怎样;

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class MapTest05 {
        public static void main(String[] args) {
            Map<User, String> map = new HashMap<>();
            // 创建四个User对象
            User u1 = new User("张三", 18);
            User u2 = new User("李四", 20);
            User u3 = new User("王五", 30);
            User u4 = new User("王五", 30); // 创建一个和u3内容一样的对象u4
            // 将User作为索引放入map中
            map.put(u1, "是个小帅哥");
            map.put(u2, "是个大帅哥");
            map.put(u3, "是个老帅哥");
            map.put(u4, "是个帅哥");
            // 输出map
            Set<Map.Entry<User, String>> set = map.entrySet();
            for (Map.Entry<User, String> i : set) {
                System.out.println(i.getKey() + " = " + i.getValue());
            }
        }
    }
    // 用户类
    class User {
        private String name; // 姓名
        private int age; // 年龄
    
        // 默认构造
        User() {}
        // 有参构造
        User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // equals方法未重写
        // hashcode方法未重写
    }
    

    输出结果:

    map.User@776ec8df = 是个小帅哥
    map.User@41629346 = 是个帅哥
    map.User@4eec7777 = 是个大帅哥
    map.User@3b07d329 = 是个老帅哥
    

    可以看到,u3和u4内容相同,但是放到HashMap中后u4并没有把u3覆盖,这样子是万万不行的;我们都知道:
    哈希表中一个索引key对应的只能是一个value值,而在这里u3和u4的索引按道理来说都相同,但是却对应不同的value值;
    这就是因为我们没有重写hashCode,我们认为的索引是u3、u4的内容,而实际情况下的索引是它们不同的hashCode值,所以就会造成这种情况的发生;

    如果重写了hashCode和equals方法呢?我们还是先看看重写后hashCode值;

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    
    public class MapTest05 {
        public static void main(String[] args) {
            Map<User, String> map = new HashMap<>();
            // 创建四个User对象
            User u1 = new User("张三", 18);
            User u2 = new User("李四", 20);
            User u3 = new User("王五", 30);
            User u4 = new User("王五", 30); // 创建一个和u3内容一样的对象u4
    
            // 先看看hashCode值
            System.out.println("u1的hashCode值为:" + u1.hashCode());
            System.out.println("u2的hashCode值为:" + u2.hashCode());
            System.out.println("u3的hashCode值为:" + u3.hashCode());
            System.out.println("u4的hashCode值为:" + u4.hashCode());
        }
    }
    // 用户类
    class User {
        private String name; // 姓名
        private int age; // 年龄
    
        // 默认构造
        User() {}
        // 有参构造
        User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // 重写equals方法
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof User)) return false;
            User user = (User) o;
            return age == user.age && name.equals(user.name);
        }
        // 重写hashCode方法
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    

    输出结果

    u1的hashCode值为:24022538
    u2的hashCode值为:26104872
    u3的hashCode值为:29050006
    u4的hashCode值为:29050006
    

    和没有重写的差别一眼就能看出来了,尤其是u3和u4,这次因为它们的对象内容是相同的,所以它们的hashCode也是相同的;
    那么这样子的话把它们放到HashMap中会怎样?看看下面代码:

    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Set;
    
    public class MapTest05 {
        public static void main(String[] args) {
            Map<User, String> map = new HashMap<>();
            // 创建四个User对象
            User u1 = new User("张三", 18);
            User u2 = new User("李四", 20);
            User u3 = new User("王五", 30);
            User u4 = new User("王五", 30); // 创建一个和u3内容一样的对象u4
            // 将User作为索引放入map中
            map.put(u1, "是个小帅哥");
            map.put(u2, "是个大帅哥");
            map.put(u3, "是个老帅哥");
            map.put(u4, "是个帅哥");
            // 输出map
            Set<Map.Entry<User, String>> set = map.entrySet();
            for (Map.Entry<User, String> i : set) {
                System.out.println(i.getKey() + " = " + i.getValue());
            }
        }
    }
    // 用户类
    class User {
        private String name; // 姓名
        private int age; // 年龄
    
        // 默认构造
        User() {}
        // 有参构造
        User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // 重写equals方法
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof User)) return false;
            User user = (User) o;
            return age == user.age && name.equals(user.name);
        }
        // 重写hashCode方法
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    

    输出结果:

    map.User@16e8e0a = 是个小帅哥
    map.User@18e5428 = 是个大帅哥
    map.User@1bb4496 = 是个帅哥
    

    可以看到输出结果变成了三个,而且因为u3和u4的内容相同,所以最后的u4的value覆盖了u3,这就实现了我们的需求:通过索引对象的内容进行比较;

    ps:如果我的语言描述有问题的话可以自己试试这几个代码,体会一下我所想要描述的意思,这一块我可能说的有点啰嗦,就有点乱,自己敲代码试试就会明白我说的是什么了;

    关于HashSet

    其实HashSet和HashMap是一样的,在HashSet底层调用了HashMap,底层代码如图:
    在这里插入图片描述
    所以记住一点就行了:HashMap需要注意的HashSet也需要注意

    总结

    说了这么多,其实就是想要说一句话:
    放在HashMap集合key部分的元素,以及放在HashSet集合中的元素,需要同时重写hashCode方法和equals方法

    这也是这篇文章讨论的核心,所以在写代码的时候一定要记住;如果没有看懂的话那就记住这句话就行了!

    对了还要注意一点:包装类和String类的hashCode方法和equals方法SUN公司都已经重写过了,所以不需要重写了!!
    可以自己写个代码验证一下,这里就不举例了;

    展开全文
  • 首先定义HashMap的key,这个类中重写equals和hashcode方法: public class Key { String key; public String getKey() { return key; } public void setKey(String key) { this.key = key; ...

    首先定义HashMap的key,这个类中重写equals和hashcode方法:

    public class Key {
        String key;
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public Key(String key) {
            this.key = key;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Key key1 = (Key) o;
            return Objects.equals(key, key1.key);
        }
    
        @Override
        public int hashCode() {
    
            return key.hashCode();
        }
    }
    

    然后创建使用:

            HashMap<Key,String> map=new HashMap();
            Key key=new Key("hyb");
            map.put(key,key.getKey());
            Key key2=new Key("hyb");
            System.out.println(map.get(key2));

    执行输出:

    hyb
    
    Process finished with exit code 0

    总结:因为重写了equals和hashCode方法,在从map中获取key2时会发现存在map的key也是hyb,从而输出值为hyb

    展开全文
  • 阅读原文:不同时重写equals和hashCode又怎样!可能一问到equals和hashCode相关的问题,就会有人讲他们的自反性,对称性,一致性,传递性等几条约定了,此时我不得不佩服,这么多约定竟然都能记得,但我不知道你...

    a1a3dd800ca426263ac78966bda55616.png

    阅读原文:不同时重写equals和hashCode又怎样!

    可能一问到equals和hashCode相关的问题,就会有人讲他们的自反性,对称性,一致性,传递性等几条约定了,
    此时我不得不佩服,这么多约定竟然都能记得,但我不知道你是不是真的理解呢。

    我不同时重写又能如何呢?

    c58d5ed304ecb45d307f8fc63288ac9e.png

    我只能说只要你不碰到这几个主,你也没什么事的!

    • 为什么不能遇到它们几个呢?
      因为它们几个会用到hashCode方法。
    • 他们用hashCode方法来干嘛?
      hashCode方法是根据对象的地址生成的一个int整数,默认它和地址一一对应的,如果不重写,那么只有对象地址一样的情况下,哈希值才相等。
      equals默认用来比较地址是否相同,但当集合中元素增多时,再使用equals判断,效率是比较低的;而哈希值是可以快速定位到指定的元素的,
      所以默认Java就使用哈希值来比较定位,因此有了Object.hashCode的约定。
      Set怎么实现存储不重复的元素的?HashMap怎么判断相同的key的?有兴趣可去深入了解一下。

    例子

    小王在「堆」中有两套房产,这两套房产位于不同的地址。现在我想要判断这两套房子是否是同一个主人?

    aae3aa82c37c9555f2705e0258ef1950.png

    于是我去问Object,而Object告诉我这两套房产不是一个人的!

    我:为什么呢?

    Object: equals告诉我两套房子离了十万八千里,在不同的地方(地址),当然不是同一个人了。

    我:这逻辑……(不符合我们常规的认知啊)

    既然这样,那我只能重写equals了!

    //注意:这是伪代码,省略了很多
    

    哈哈,好啦,现在equals终于知道这两个房子是同一人的啦!

    然而在房产管理局(HashMap)我得到一个消息:小王只要一套房产!

    WTF!我白干了!

    房产管理局(HashMap): 不信你看!

    HashMap

    遇到你真是倒霉了,原来房产管理局(HashMap)使用了hashCode来计算的!想要正确的统计小王的房产只能重写hashCode方法了。

    @Override
     

    此时,他们统计终于对了!!!

    总结

    除非你能保证你重写equals的类不被Set,Map使用,否则你就必须同时重写equals和hashCode。

    你能保证吗?如果不想同时重写,你可以这样:

    /**
     * 1.此类应用于Set,Map时,需要使用者重写hashCode,违规者后果自负
     * 2.本类不能作为第三方类库供其他项目使用 
     * @author flyhero
     * @date 2019-04-03 6:14 PM
     */
    public class User {}

    信不信这样写,老大看到后,就say goodbye了!

    如何重写equals与hashCode

    我就不写出常说的那些约定性质了,写了也记不住。说说如何避免违反这些约定:

    重写equals

    1. 通过==判断是否是同一个引用
    2. 通过instanceof判断是否是相同类型
    3. 把参数转为正确的类型
    4. 对比双方各个属性值是否相同

    如:

     @Override
     public boolean equals(Object obj) {
     if (this == obj) {
     return true;
     }
     if (!(obj instanceof User)) {
     return false;
     }
     User user = (User) obj;
     return this.name.equals(user.name)
     && this.idCard.equals(user.idCard);
     }
    

    重写hashCode

    hashCode方法应该为“不相等的对象产生不相等的哈希值”

    一般计算是根据你equals中用来比较的属性的hashCode组合计算的,不过目前JDK和一些类库已经给我提供了很好的重写方式,我们可不必去深究其中算法。

    • 方式一
    @Override
     public int hashCode() {
     return Objects.hash(name, idCard);
     }


    使用了JDK自带Objects提供的静态方法。

    • 方式二
    @EqualsAndHashCode 
     public class User {} 


    使用了lombok类库,直接在类上注解即可。

    更多精彩技术文章尽在微信公众号:码上实战

    展开全文
  • 最近面试了很多人,大部分人都搞不明白为什么重写equals方法一定要重写hashcode。大家都知道,equals和hashcode是java.lang.Object类的两个重要的方法,在实际应用中常常需要重写这两个方法。节选自Object类上2个...
  • 首先从源码的角度来看一看equals()方法的hashcode()方法的含义equals()方法和hashcode()方法都属于Object类,在Java中,所有的类都是Object类的子类,也就是说,任何Java对象都可调用Object类的方法equals...
  • 重写equals方法

    2019-12-02 17:23:40
    重写equals方法 相信在每个人都有过重写过java的equals的方法的经历。这篇博文就从以下几个方面说明重写equals方法的原由,与君共进步。 一 为什么要重写equals方法 首先我们了解equals方法的作用是什么? java的...
  • import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Demo { public static void main(String[] args) { HashMap<String,Student> map=new ...
  • 对象作为HashMap的键为什么要重写equals方法和hashCode方法 package com.zzy.xuexi_utils.pojo; import java.util.Objects; /** * @author zzy * @create 2021/5/4 */ public class User { private String ...
  • 目录为什么需要重写equals方法? 为什么需要重写equals方法? 比方创建一个Student类,定义了一个全参构造方法 public class Student { private String name; private Integer stuId; public Student(String ...
  • 1.何时需要重写equals() 当一个类有自己特有的“逻辑相等”概念(不同于对象身份的概念)。 2.设计equals() [1]使用instanceof操作符检查“实参是否为正确的类型”。 [2]对于类中的每一个“关键域”,检查实参中...
  • 最近在面试的时候,当问完了HashMap的数据结构之后,通常会再多问一个问题,就是:重写equals方法时通常为什么也要重写一下hashcode方法? 其实这个问题,本质上又回到HashMap的应用场景了,就是想看一下面试者是否...
  • 作者:flyhero微信公众号:码上实战(ID:Push-Code)可能一问到equals和hashCode相关的问题,就会有人讲他们的自反性,对称性,一致性,传递性等几条约定了,此时我不得不佩服,这么多约定竟然都能记得,但我不知道你...
  • 为什么重写equals方法一定要重写hashcode方法 先来看看如果重写类的equals方法,但是没有重写hashcode方法会发生什么。 例如: 重写了一个类HashTest的equals方法,但是没有重写HashTest的hashCode方法,它的两个...
  • map中使用自定义类型,需要重写equals 和 hashCode @Override public boolean equals(Object obj) { /** * 判断传入的类,是否为 目标实体类 */ if (obj instanceof Student) { /** ...
  • 可能一问到equals和hashCode相关的问题,就会有人讲他们的自反性,对称性,一致性,传递性等几条约定了,此时我不得不佩服,这么多约定竟然都能记得,但我不知道你是不是真的理解呢。一、我不同时重写又能如何呢?我...
  • 在我们平时编写Java代码时,重写equals方法时一定要重写hashCode方法,这是为什么呢? 在讨论这个问题前,我们先看下Object类中hashCode方法和equals方法。 hashCode方法: 翻译如下: equals方法: 翻译如下: ...
  • 文章目录1、hashCode与equals两者之间的关系2、== 和equals的区别`3、为什么要重写equals()方法?4、重写equals()方法5、为什么要重写hashCode()方法?6、什么时候需要重写hashCode()方法?7、重写hashCode()方法: ...
  • 看到很多博客把标题设置成 "为什么重写equals方法后一定要重写hashcode方法",虽然这是个面试题,事实上,若不看情况地将该命题一概而论,很容易造成不必要的误解。上述标题易把equals和hashCode之间形成因果关系,...
  • java 重写equals方法

    2017-09-01 10:20:11
    我们有的时候要判断我们自己定义的类生成的对象的值是否相等,这时候就要重写equals方法,如果不重写,就无法判断两个对象的值是否相等! Object类是我们自己定义类的父类,在Object类中equals方法是这样的: public...
  • HashMap和Hashtable的底层实现都是数组+链表结构实现的使用HashMap,如果key是自定义的类,就必须重写hashcode()和equals()。如果你重载了equals,比如说是基于对象的内容实现的,而保留hashCode的实现不变,那么很...
  • 我们知道重写equals方法必须重写hashcode方法,此文从一些使用角度分析原因 1. hashCode方法源码 public class Object { /** * Returns a hash code value for the object. This method is * supported for ...
  • java Guide里说到了为什么要重写hashcode的原因: 为什么重写equals时必须重写hashcode方法
  • 出处:cnblogs.com/JavaArchitect/p/10474448.html我在面试 Java初级开发的时候,经常会问:你有没有重写过hashcode方法?不少候选人直接说没写过。我就想,或许真的没写过,于是就再通过一个问题确认:你在用...
  • 在java笔试和面试中,经常会遇到“重写equals方法是否要重写hashCode方法“的问题。正好最近看到《effective java》中的这个地方,标题就是“覆盖equals方法总要覆盖hashCode方法”。 先看代码,本地也写了个demo,...
  • 在我们需要比较对象是否相等时,我们往往需要采取重写equals方法和hashcode方法。 该篇,就是从比较对象的场景结合通过代码实例以及部分源码解读,去跟大家品一品这个重写equals方法和hashcode方法。 正文 ...
  • 重写equals()3. hashCode与equals的区别和联系3.1 Hash3.2 HashCode 1. == 与 equals的区别 如果两个引用类型变量使用==运算符,那么比较的是地址,它们分别指向的是否是同一地址的对象,结果一定是false,因为两...
  • 一、重写equals方法,还要重写hashcode就是要保证当两个对象equals的时候也要保证两者的hashcode值是一样的。 为什么要这么做?下面有俩个原则要知道: 1.两个对象如果互相equals,那么他们的hashcode值一定是相同的...
  • 1、首先我们看看对象默认的(Object)的equals方法和hashcode方法 public booleanequals(Object ...对象在不重写的情况下使用的是Object的equals方法和hashcode方法,从Object类的源码我们知道,默认的equals 判断...
  • 为什么说重写equals方法一定要重写hashCode方法? 导语:在进行知识讲解这前 我们先了解以下知识 在jvm层面来说 我们每一个对象都有hashCode 即hash散列码 他是对象的身份证 hashCode方法是Java本地方法(当然也在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,427
精华内容 25,770
关键字:

hashmap重写equals方法