37

我有一个用于存储对象的 HashMap：

    private Map<T, U> fields = Collections.synchronizedMap(new HashMap<T, U>());

但是，当尝试检查键是否存在时，containsKey方法返回false.
equals和hashCode方法都实现了，但是没有找到key。
在调试一段代码时：

    return fields.containsKey(bean) && fields.get(bean).isChecked();

我有：

   bean.hashCode() = 1979946475 
   fields.keySet().iterator().next().hashCode() = 1979946475    
   bean.equals(fields.keySet().iterator().next())= true 
   fields.keySet().iterator().next().equals(bean) = true

但

fields.containsKey(bean) = false

什么会导致这种奇怪的行为？

public class Address extends DtoImpl<Long, Long> implements Serializable{

   <fields>
   <getters and setters>

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + StringUtils.trimToEmpty(street).hashCode();
    result = prime * result + StringUtils.trimToEmpty(town).hashCode();
    result = prime * result + StringUtils.trimToEmpty(code).hashCode();
    result = prime * result + ((country == null) ? 0 : country.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Address other = (Address) obj;
    if (!StringUtils.trimToEmpty(street).equals(StringUtils.trimToEmpty(other.getStreet())))
        return false;
    if (!StringUtils.trimToEmpty(town).equals(StringUtils.trimToEmpty(other.getTown())))
        return false;
    if (!StringUtils.trimToEmpty(code).equals(StringUtils.trimToEmpty(other.getCode())))
        return false;
    if (country == null) {
        if (other.country != null)
            return false;
    } else if (!country.equals(other.country))
        return false;
    return true;
}


}
4

4 回答 4

29

将密钥插入地图后不得修改。

编辑：我在Map中找到了 javadoc 的摘录：

注意：如果将可变对象用作映射键，则必须非常小心。如果对象的值以影响等于比较的方式更改，而对象是映射中的键，则不指定映射的行为。

带有简单包装类的示例：

public static class MyWrapper {

  private int i;

  public MyWrapper(int i) {
    this.i = i;
  }

  public void setI(int i) {
    this.i = i;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    return i == ((MyWrapper) o).i;
  }

  @Override
  public int hashCode() {
    return i;
  }
}

和测试：

public static void main(String[] args) throws Exception {
  Map<MyWrapper, String> map = new HashMap<MyWrapper, String>();
  MyWrapper wrapper = new MyWrapper(1);
  map.put(wrapper, "hello");
  System.out.println(map.containsKey(wrapper));
  wrapper.setI(2);
  System.out.println(map.containsKey(wrapper));
}

输出 ：

true
false

注意：如果你不覆盖 hashcode() 那么你只会得到 true

于 2014-02-06T11:01:20.820 回答
12

正如 Arnaud Denoyelle 指出的那样，修改密钥可以产生这种效果。原因是它关心containsKey哈希映射中键的桶，而迭代器不关心。如果您的地图中的第一个键 - 忽略存储桶 - 恰好是您想要的，那么您可以获得您所看到的行为。如果地图中只有一个条目，这当然是有保证的。

想象一个简单的两桶地图：

[0: empty]  [1: yourKeyValue]

迭代器是这样的：

  • 遍历桶 0 中的所有元素：没有
  • 遍历桶 1 中的所有元素：只有一个yourKeyValue

然而containsKey，方法是这样的：

  • keyToFind有一个hashCode() == 0，所以让我看一下桶 0（并且只有那里）。哦，它是空的——返回false.

事实上，即使密钥在同一个桶中，你仍然会遇到这个问题！如果您查看 的实现HashMap，您会看到每个键值对都与键的哈希码一起存储。当地图想要根据传入的密钥检查存储的密钥时，它会同时使用这个 hashCode 和密钥的equals：

((k = e.key) == key || (key != null && key.equals(k))))

这是一个很好的优化，因为这意味着碰巧碰撞到同一个桶中的具有不同 hashCode 的键将被视为不相等非常便宜（只是一个int比较）。但这也意味着更改密钥（不会更改存储e.key字段）会破坏地图。

于 2014-02-06T11:06:18.640 回答
7

调试 java 源代码我意识到方法 containsKey 针对键集中的每个元素检查搜索键上的两件事： hashCode和equals；它按那个顺序做。

这意味着 if obj1.hashCode() != obj2.hashCode()，它返回 false （不评估 obj1.equals(obj2)。但是，如果obj1.hashCode() == obj2.hashCode()，那么它返回obj1.equals(obj2)

您必须确保这两种方法 - 可能是您必须覆盖它们 - 为您定义的标准评估为 true。

于 2014-06-03T22:15:48.923 回答
1

下面是SSCCE针对您的问题。它就像一个魅力，它不可能是别的，因为你的hashCode和equals方法似乎是由 IDE 自动生成的，它们看起来很好。

所以，关键词是when debugging。调试本身可能会损害您的数据。例如，在调试窗口的某处，您设置了更改fields对象或bean对象的表达式。之后，您的其他表达式会给您带来意想不到的结果。

尝试将所有这些检查添加到您的方法中，从那里获得return声明并打印出它们的结果。

import org.apache.commons.lang.StringUtils;

import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class Q21600344 {

    public static void main(String[] args) {
        MapClass<Address, Checkable> mapClass = new MapClass<>();
        mapClass.put(new Address("a", "b", "c", "d"), new Checkable() {
            @Override
            public boolean isChecked() {
                return true;
            }
        });

        System.out.println(mapClass.isChecked(new Address("a", "b", "c", "d")));
    }

}

interface Checkable {
    boolean isChecked();
}

class MapClass<T, U extends Checkable> {
    private Map<T, U> fields = Collections.synchronizedMap(new HashMap<T, U>());

    public boolean isChecked(T bean) {
        return fields.containsKey(bean) && fields.get(bean).isChecked();
    }

    public void put(T t, U u) {
        fields.put(t, u);
    }
}

class Address implements Serializable {

    private String street;
    private String town;
    private String code;
    private String country;

    Address(String street, String town, String code, String country) {
        this.street = street;
        this.town = town;
        this.code = code;
        this.country = country;
    }

    String getStreet() {
        return street;
    }

    String getTown() {
        return town;
    }

    String getCode() {
        return code;
    }

    String getCountry() {
        return country;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + StringUtils.trimToEmpty(street).hashCode();
        result = prime * result + StringUtils.trimToEmpty(town).hashCode();
        result = prime * result + StringUtils.trimToEmpty(code).hashCode();
        result = prime * result + ((country == null) ? 0 : country.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Address other = (Address) obj;
        if (!StringUtils.trimToEmpty(street).equals(StringUtils.trimToEmpty(other.getStreet())))
            return false;
        if (!StringUtils.trimToEmpty(town).equals(StringUtils.trimToEmpty(other.getTown())))
            return false;
        if (!StringUtils.trimToEmpty(code).equals(StringUtils.trimToEmpty(other.getCode())))
            return false;
        if (country == null) {
            if (other.country != null)
                return false;
        } else if (!country.equals(other.country))
            return false;
        return true;
    }


}
于 2014-02-06T11:07:08.623 回答