从java中用户定义的hashmap键搜索perticular对象元素

Question

我想在java hashmap中搜索用户定义键中的元素，例如

可以在这个例子中搜索hm.containsKey（new Price（“Banana”，20）），  但在这个例子中，我想按特定数据成员搜索，如价格或项目明智。

public class MyObjectKeySearch {
 
public static void main(String a[]){
         
        HashMap<Price, String> hm = new HashMap<Price, String>();
        hm.put(new Price("Banana", 20), "Banana");
        hm.put(new Price("Apple", 40), "Apple");
        hm.put(new Price("Orange", 30), "Orange");
        printMap(hm);
        Price key = new Price("Banana", 20);
        System.out.println("Does key available? "+hm.containsKey(key));
    }
     
    public static void printMap(HashMap<Price, String> map){
         
        Set<Price> keys = map.keySet();
        for(Price p:keys){
            System.out.println(p+"==>"+map.get(p));
        }
    }
}
 
class Price{
     
    private String item;
    private int price;
     
    public Price(String itm, int pr){
        this.item = itm;
        this.price = pr;
    }
     
    public int hashCode(){
        System.out.println("In hashcode");
        int hashcode = 0;
        hashcode = price*20;
        hashcode += item.hashCode();
        return hashcode;
    }
     
    public boolean equals(Object obj){
        System.out.println("In equals");
        if (obj instanceof Price) {
            Price pp = (Price) obj;
            return (pp.item.equals(this.item) && pp.price == this.price);
        } else {
            return false;
        }
    }
     
    public String getItem() {
        return item;
    }
    public void setItem(String item) {
        this.item = item;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
     
    public String toString(){
        return "item: "+item+"  price: "+price;
    }
}

Answer 1

是：

hm.containsKey(new Price("Banana", 20))

是可能的，并且表现得像您期望的那样。

否： 您不能根据不涉及迭代HashMap密钥集的密钥对象的成员进行任何包含检查。如果key.hashCode（）标识的相应“哈希桶”中的密钥等于 paramKey ，则 containsKey（paramKey）返回true。 hashCode（）的值模糊了成员值。 您可以使用更复杂的数据结构，如嵌套的HashMap：

HashMap<String, HashMap<Integer, String>> hm;

使用 item 将字符串作为外部Map中的键，将 price Integers用作内部Map中的键。然后你可以查询：

(hm.containsKey("Banana") && hm.get("Banana").containsKey(20))

这比迭代大量的 Price 对象要高效得多。但是，这仍然不允许您有效地查询具有特定价格（整数）的所有内部条目，而无需迭代外部密钥集。您可以相应地反转内部和外部键类型：

HashMap<Integer, HashMap<String, String>> hm;

当然，您可以创建自己的类来封装两者的功能：

/* Provides constant time (O(1)) Price lookup by item and price */
class PriceMap {
    private HashMap<String, Set<Price>> stringMap;
    private HashMap<Integer, Set<Price>> intMap;

    public PriceMap() {
        stringMap = new HashMap<String, Set<Price>>();
        intMap = new HashMap<Integer, Set<Price>>();
    }

    public void add(Price price) {
        String item = price.getItem()
        if (!stringMap.containsKey(item))
            stringMap.put(item, new HashSet<Price>());
        stringMap.get(item).add(Price);
        int price = price.getPrice()
        if (!intMap.containsKey(price))
            intMap.put(price, new HashSet<Price>());
        intMap.get(price).add(Price);
    }

    public Set<Price> prices(int price) {
        return intMap.containsKey(price) ? intMap.get(price) : new HashSet<Price>(); 
    }

    public boolean containsKey(int price) {
        return intMap.containsKey(price); 
    }

    public Set<Price> prices(String item) {
        return stringMap.containsKey(item) ? stringMap.get(item) : new HashSet<Price>(); 
    }

    public boolean containsKey(String item) {
        return stringMap.containsKey(item); 
    }

}