精华内容
下载资源
问答
  • 本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢? HashMap是一种用哈希值来存储和查找键值对(key-value pair,也称作entry...
     
    

    本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢?

    HashMap是一种用哈希值来存储和查找键值对(key-value pair,也称作entry)的一种数据结构。

    为了正确使用HashMap,选择恰当的Key是非常重要的。Key在HashMap里是不可重复的。

    内容

    1. 什么是可变对象
    2. HashMap如何存储键值对
    3. 在HashMap中使用可变对象作为Key带来的问题
    4. 如何解决

    1、什么是可变对象

    可变对象是指创建后自身状态能改变的对象。换句话说,可变对象是该对象在创建后它的哈希值可能被改变。

    在下面的代码中,对象MutableKey的键在创建时变量 i=10 j=20,哈希值是1291。

    然后我们改变实例的变量值,该对象的键 i 和 j 从10和20分别改变成30和40。现在Key的哈希值已经变成1931。

    显然,这个对象的键在创建后发生了改变。所以类MutableKey是可变的。

    让我们看看下面的示例代码:

    注意:调用hashCode()时,equals()方法也同时被执行。

    publicclass MutableKey {
        privateint i;
        privateint j;
     
        publicMutableKey(inti, intj) {
            this.i = i;
            this.j = j;
        }
     
        publicfinal int getI() {
            returni;
        }
     
        publicfinal void setI(inti) {
            this.i = i;
        }
     
        publicfinal int getJ() {
            returnj;
        }
     
        publicfinal void setJ(intj) {
            this.j = j;
        }
     
        @Override
        publicint hashCode() {
            finalint prime = 31;
            intresult = 1;
            result = prime * result + i;
            result = prime * result + j;
            returnresult;
        }
     
        @Override
        publicboolean equals(Object obj) {
            if(this== obj) {
                returntrue;
            }
            if(obj == null) {
                returnfalse;
            }
            if(!(obj instanceofMutableKey)) {
                returnfalse;
            }
            MutableKey other = (MutableKey) obj;
            if(i != other.i) {
                returnfalse;
            }
            if(j != other.j) {
                returnfalse;
            }
            returntrue;
        }
    }


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class MutableDemo {
     
         public static void main(String[] args) {
     
             // Object created
             MutableKey key = new MutableKey( 10 , 20 );
             System.out.println( "Hash code: " + key.hashCode());
     
             // Object State is changed after object creation.
             key.setI( 30 );
             key.setJ( 40 );
             System.out.println( "Hash code: " + key.hashCode());
         }
    }

    输出:

    1
    2
    Hash code: 1291
    Hash code: 1931

    2、HashMap如何存储键值对

    HashMap用Key的哈希值来存储和查找键值对。

    当插入一个Entry时,HashMap会计算Entry Key的哈希值。Map会根据这个哈希值把Entry插入到相应的位置。

    查找时,HashMap通过计算Key的哈希值到特定位置查找这个Entry。

    3、在HashMap中使用可变对象作为Key带来的问题

    如果HashMap Key的哈希值在存储键值对后发生改变,Map可能再也查找不到这个Entry了。

    如果Key对象是可变的,那么Key的哈希值就可能改变。在HashMap中可变对象作为Key会造成数据丢失。

    下面的例子将会向你展示HashMap中有可变对象作为Key带来的问题。

    importjava.util.HashMap;
    importjava.util.Map;
     
    publicclassMutableDemo1 {
     
        publicstaticvoidmain(String[] args) {
     
            // HashMap
            Map<MutableKey, String> map = newHashMap<>();
     
            // Object created
            MutableKey key = newMutableKey(10,20);
     
            // Insert entry.
            map.put(key,"Robin");
     
            // This line will print 'Robin'
            System.out.println(map.get(key));
     
            // Object State is changed after object creation.
            // i.e. Object hash code will be changed.
            key.setI(30);
     
            // This line will print null as Map would be unable to retrieve the
            // entry.
            System.out.println(map.get(key));
        }
    }


    输出:

    1
    2
    Robin
    null

    4、如何解决

    在HashMap中使用不可变对象。在HashMap中,使用String、Integer等不可变类型用作Key是非常明智的。

    我们也能定义属于自己的不可变类。

    如果可变对象在HashMap中被用作键,那就要小心在改变对象状态的时候,不要改变它的哈希值了。

    在下面的Employee示例类中,哈希值是用实例变量id来计算的。一旦Employee的对象被创建,id的值就不能再改变。只有name可以改变,但name不能用来计算哈希值。所以,一旦Employee对象被创建,它的哈希值不会改变。所以Employee在HashMap中用作Key是安全的。

    示例代码:

    importjava.util.HashMap;
    importjava.util.Map;
     
    publicclassMutableSafeKeyDemo {
     
        publicstaticvoid main(String[] args) {
            Employee emp = newEmployee(2);
            emp.setName("Robin");
     
            // Put object in HashMap.
            Map<Employee, String> map = newHashMap<>();
            map.put(emp,"Showbasky");
     
            System.out.println(map.get(emp));
     
            // Change Employee name. Change in 'name' has no effect
            // on hash code.
            emp.setName("Lily");
            System.out.println(map.get(emp));
        }
    }
     
    classEmployee {
        // It is specified while object creation.
        // Cannot be changed once object is created. No setter for this field.
        privateintid;
        privateString name;
     
        publicEmployee(finalintid) {
            this.id = id;
        }
     
        publicfinalString getName() {
            returnname;
        }
     
        publicfinalvoid setName(finalString name) {
            this.name = name;
        }
     
        publicintgetId() {
            returnid;
        }
     
        // Hash code depends only on 'id' which cannot be
        // changed once object is created. So hash code will not change
        // on object's state change
        @Override
        publicinthashCode() {
            finalintprime = 31;
            intresult = 1;
            result = prime * result + id;
            returnresult;
        }
     
        @Override
        publicbooleanequals(Object obj) {
            if(this== obj)
                returntrue;
            if(obj == null)
                returnfalse;
            if(getClass() != obj.getClass())
                returnfalse;
            Employee other = (Employee) obj;
            if(id != other.id)
                returnfalse;
            returntrue;
        }
    }


    输出:

    1
    2
    Showbasky
    Showbasky

    现在你可能已经理解在HashMap中用可变对象作为Key的危险了。关于本文欢迎提出的任何建议和意见。

    展开全文
  • HashMap中使用不可变对象。在HashMap中,使用String、Integer等不可变类型用作Key是非常明智的。 我们也能定义属于自己的不可变类。 如果可变对象HashMap中被用作键,那就要小心在改变对象状态的时候,不要...

    本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢?

    HashMap是一种用哈希值来存储和查找键值对(key-value pair,也称作entry)的一种数据结构。

    为了正确使用HashMap,选择恰当的Key是非常重要的。Key在HashMap里是不可重复的。

    内容

    什么是可变对象 HashMap如何存储键值对 在HashMap中使用可变对象作为Key带来的问题 如何解决

    1、什么是可变对象

    可变对象是指创建后自身状态能改变的对象。换句话说,可变对象是该对象在创建后它的哈希值可能被改变。

    在下面的代码中,对象MutableKey的键在创建时变量 i=10 j=20,哈希值是1291。

    然后我们改变实例的变量值,该对象的键 i 和 j 从10和20分别改变成30和40。现在Key的哈希值已经变成1931。

    显然,这个对象的键在创建后发生了改变。所以类MutableKey是可变的。

    让我们看看下面的示例代码:

    注意: 调用hashCode()时,equals()方法也同时被执行。

    public class MutableKey {
        private int i;
        private int j;
     
        public MutableKey(int i, int j) {
            this.i = i;
            this.j = j;
        }
     
        public final int getI() {
            return i;
        }
     
        public final void setI(int i) {
            this.i = i;
        }
     
        public final int getJ() {
            return j;
        }
     
        public final void setJ(int j) {
            this.j = j;
        }
     
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + i;
            result = prime * result + j;
            return result;
        }
     
        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (!(obj instanceof MutableKey)) {
                return false;
            }
            MutableKey other = (MutableKey) obj;
            if (i != other.i) {
                return false;
            }
            if (j != other.j) {
                return false;
            }
            return true;
        }
    }
    
    public class MutableDemo {
     
        public static void main(String[] args) {
     
            // Object created
            MutableKey key = new MutableKey(10, 20);
            System.out.println("Hash code: " + key.hashCode());
     
            // Object State is changed after object creation.
            key.setI(30);
            key.setJ(40);
            System.out.println("Hash code: " + key.hashCode());
        }
    }
    

    输出:

    Hash code: 1291
    Hash code: 1931
    

    2、HashMap如何存储键值对

    HashMap用Key的哈希值来存储和查找键值对。

    当插入一个Entry时,HashMap会计算Entry Key的哈希值。Map会根据这个哈希值把Entry插入到相应的位置。

    查找时,HashMap通过计算Key的哈希值到特定位置查找这个Entry。

    3、在HashMap中使用可变对象作为Key带来的问题

    如果HashMap Key的哈希值在存储键值对后发生改变,Map可能再也查找不到这个Entry了。

    如果Key对象是可变的,那么Key的哈希值就可能改变。在HashMap中可变对象作为Key会造成数据丢失。

    下面的例子将会向你展示HashMap中有可变对象作为Key带来的问题。

    import java.util.HashMap;
    import java.util.Map;
     
    public class MutableDemo1 {
     
        public static void main(String[] args) {
     
            // HashMap
            Map<MutableKey, String> map = new HashMap<>();
     
            // Object created
            MutableKey key = new MutableKey(10, 20);
     
            // Insert entry.
            map.put(key, "Robin");
     
            // This line will print 'Robin'
            System.out.println(map.get(key));
     
            // Object State is changed after object creation.
            // i.e. Object hash code will be changed.
            key.setI(30);
     
            // This line will print null as Map would be unable to retrieve the
            // entry.
            System.out.println(map.get(key));
        }
    }
    

    输出:

    Robin
    null
    

    4、如何解决

    在HashMap中使用不可变对象。在HashMap中,使用String、Integer等不可变类型用作Key是非常明智的。

    我们也能定义属于自己的不可变类。

    如果可变对象在HashMap中被用作键,那就要小心在改变对象状态的时候,不要改变它的哈希值了。

    在下面的Employee示例类中,哈希值是用实例变量id来计算的。一旦Employee的对象被创建,id的值就能再改变。只有name可以改变,但name不能用来计算哈希值。所以,一旦Employee对象被创建,它的哈希值不会改变。所以Employee在HashMap中用作Key是安全的。

    示例代码:

    import java.util.HashMap;
    import java.util.Map;
     
    public class MutableSafeKeyDemo {
     
        public static void main(String[] args) {
            Employee emp = new Employee(2);
            emp.setName("Robin");
     
            // Put object in HashMap.
            Map<Employee, String> map = new HashMap<>();
            map.put(emp, "Showbasky");
     
            System.out.println(map.get(emp));
     
            // Change Employee name. Change in 'name' has no effect
            // on hash code.
            emp.setName("Lily");
            System.out.println(map.get(emp));
        }
    }
     
    class Employee {
        // It is specified while object creation.
        // Cannot be changed once object is created. No setter for this field.
        private int id;
        private String name;
     
        public Employee(final int id) {
            this.id = id;
        }
     
        public final String getName() {
            return name;
        }
     
        public final void setName(final String name) {
            this.name = name;
        }
     
        public int getId() {
            return id;
        }
     
        // Hash code depends only on 'id' which cannot be
        // changed once object is created. So hash code will not change
        // on object's state change
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + id;
            return result;
        }
     
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Employee other = (Employee) obj;
            if (id != other.id)
                return false;
            return true;
        }
    }
    

    输出:

    Showbasky
    Showbasky
    

    现在你可能已经理解在HashMap中用可变对象作为Key的危险了。关于本文欢迎提出的任何建议和意见。

    原文链接: http://www.java-fries.com/2014/09/mutable-keys-in-hashmap-dangerous-practice/

    展开全文
  • 为什么HashMap中key需要为不可变对象

    千次阅读 2017-07-31 17:17:15
    我们都提倡HashMap中key需要为不可变对象,但是事实上,如果你硬要将HashMap的key为可变对象也是可以的,但是这样会带来很多潜在的危险。HashMap, Object> changeMap = new HashMap(); List<String> list = new ...

    我们都提倡HashMap中key需要为不可变对象,但是事实上,如果你硬要将HashMap的key为可变对象也是可以的,但是这样会带来很多潜在的危险。

    HashMap<List<String>, Object> changeMap = new HashMap<>();
    List<String> list = new ArrayList<>();
    list.add("hello");
    list.add("world");
    Object objectValue = new Object();
    changeMap.put(list, objectValue);
    System.out.println(changeMap.get(list));
    list.add("hello world");
    System.out.println(changeMap.get(list));
    
    /*
    代码结果:
    java.lang.Object@74a14482
    null
    */

    原因是因为key的hashCode变了。

    这是ArrayList的hashCode方法:

    /**
     * Returns the hash code value for this list.
     *
     * <p>This implementation uses exactly the code that is used to define the
     * list hash function in the documentation for the {@link List#hashCode}
     * method.
     *
     * @return the hash code value for this list
     */
    public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }

    当增加元素的时候,hashCode也在变化,这样一来,原来的key对应的value就找不到了。

    展开全文
  • HashMap中使用可变对象作为Key带来的问题 ,所以能直接使用@Data注解。 修复此问题的方法很简单: 使用@Getter @Setter @ToString代替@Data并且自定义equals(Object other) 和 hashCode()方法,比如有些类只...

    当使用Lombok框架时,使用它的@Data注解是非常诱人的。因为 @Data注解会自动添加以下注解:

    • @Getter
    • @Setter
    • @RequiredArgsConstructor
    • @ToString
    • @EqualsAndHashCode

    官方文档:@EqualsAndHashCode
    通过阅读官方文档可知以下几点:
    1. @EqualsAndHashCode会生成equals(Object other) 和 hashCode()方法。
    2. 可通过callSuper=true解决上一点问题。让其生成的方法中调用父类的方法。

    通过官方文档,可以得知,当使用@Data注解时,则有了@EqualsAndHashCode注解,那么就会在此类中存在equals(Object other) 和 hashCode()方法,且不会使用父类的属性,这就导致了可能的问题。
    比如,有多个类有相同的部分属性,把它们定义到父类中,恰好id(数据库主键)也在父类中,那么就会存在部分对象在比较时,它们并不相等,却因为lombok自动生成的equals(Object other) 和 hashCode()方法判定为相等,从而导致出错。

    由于我在项目中将对象作为key放入了HashMap中,导致了HashMap中使用可变对象作为Key带来的问题,所以不能直接使用@Data注解。

    修复此问题的方法很简单:

    1. 使用@Getter @Setter @ToString代替@Data并且自定义equals(Object other) 和 hashCode()方法,比如有些类只需要判断主键id是否相等即足矣。
    2. 或者使用在使用@Data时同时加上@EqualsAndHashCode(callSuper=true)注解。

    参考:https://www.cnblogs.com/weirdo-lenovo/p/10789351.html
    https://blog.csdn.net/jenny8080/article/details/52302796

    展开全文
  • 文章目录四个线程安全策略不可变对象定义不可变对象需要满足的条件如何创建不可变对象使用final关键字定义不可变对象修饰变量示例final 修饰基本数据类型及String: 初始化之后不能修改 (线程安全)final修饰引用...
  • 深入理解Java中的不可变对象

    千次阅读 2020-03-20 10:49:23
    二哥,你能给我说说为什么 String 是 immutable 类(不可变对象)吗?我想研究它,想知道为什么它就不可变了,这种强烈的愿望就像想研究浩瀚的星空一样。但无奈自身功力有限,始终觉得雾里看花终隔一层。二哥你的...
  • Java不可变对象

    千次阅读 2017-01-12 13:45:46
    一、不可变类简介 不可变类:所谓的不可变类是指这个类的实例一旦创建完成后,就不能改变其成员变量值。如JDK内部自带的很多不可变类:Interger、Long和String等。 可类:相对于不可变类,可类创建实例后可以...
  • 内存有效的不可变HashMap 该库提供了一种简单的开放式寻址有序哈希表实现。 该实现以及积极的对象重用策略(在此也提供)可以导致半结构化哈希映射的内存使用率极低。 这对于表示小的不可变事件非常有用。 ...
  • HashMap的key是对象

    千次阅读 2018-05-11 18:22:33
    使用HashMap,如果key是自定义的类,就必须重写... 而对于每一个对象,通过其hashCode()方法为其生成一个整形值(散列码),该整型值被处理后,将会作为数组下标,存放该对象所对应的Entry(存放该对象及其对...
  • 前言:hashmap是数据+链表的结构,决定它的元素在内存的位置的是key的hashcode值,当然该元素的位置的最终确定还取决于该hashmap中是否已经有相同hashcode值的其他元素,我们来看源码: 修改一个key-value键值对...
  • HashMap 转化为Bean对象

    千次阅读 2019-11-27 15:11:28
    1,使用了以下的方法,但是空异常 ...2,使用gson,但是出现部分字段数据能转换过去,报null Gson gson = new Gson(); String jsonStr = gson.toJson(tempList.get(0)); LabUser user = gson.f...
  • hashMap实现原理

    万次阅读 多人点赞 2019-07-31 18:35:50
    1. HashMap概述:  HashMap是基于哈希表的Map接口的非同步实现(Hashtable跟...此类保证映射的顺序,特别是它保证该顺序恒久不变。 2. HashMap的数据结构:  在java编程语言中,最基本的结构就是两种,一...
  • 创建后状态不能被修改的对象叫作不可变对象不可变对象天生就是线程安全的。它们的常量(变量)是在构造函数中创建的,既然它们的状态无法被修改,那么这些常量永远不会被改变——不可变对象永远是线程安全的。 ...
  • 【Java并发编程】不可变对象

    千次阅读 2019-10-29 14:10:02
    不可变对象 一、介绍 二、集合框架的不可变 不可变对象 一、介绍 不可变对象,顾名思义。不可变对象是避免对象被发布的一个重要的手段。 对象不可变需要满足以下条件 对象创建以后其状态就不能修改 ...
  • HashMap使用对象作为key实现

    万次阅读 2018-04-19 17:25:59
    HashMap在使用可变对象作为key是一件很危险的事情 我们开始一个简单的实例 class People{ private String name; private int age; public People(){ } public People(String name, int age) { this.name =...
  • HashMap

    千次阅读 2021-10-03 20:20:01
    五、HashMap 在 put 时,如果数组中已经有了这个 key,我想把 value 覆盖怎么办?取值时,如果得到的 value 是空时,想返回默认值怎么办? 前言 HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有选的...
  • Immutable Object(不可变对象
  • 对象作为HashMap的key

    千次阅读 2019-08-02 23:29:58
    在实际使用中如果遇到对象作为HashMap结构的key,则一定要注意重写equals和hashCode两个方法。以JDK8为例,HashMap在put(K key, V value)方法和containsKey(Object key)方法都会进行当前HashMap中是否已有待放入的...
  • 如果使用可变类作为HashMap的键值,而重写HashCode 和equals 方法,使用会产生同一键(对等的两个对象)存在两个地方的问题,产生可以存在重复键值 的假象。为什么会产生这种现象,这就得看HashMap 怎么进行

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 211,680
精华内容 84,672
热门标签
关键字:

hashmap不可变对象