比较 hastable 和 equals

Question

我有一个相当愚蠢的问题，但我想知道在编译器为我们做之前将哈希映射的输入与equals() 进行比较是否可以实现。我正在尝试计算我在地图中输入重复键值对的次数。

我已经编写了一些代码，但我不知道如何实现equals()。有什么想法吗？

Map<String, String> newMap = new LinkedHashMap<>();
    newMap.put("aaa", "bbb");
    newMap.put("ccc", "ddd");
    newMap.put("eee", "fff");
    newMap.put("aaa", "bbb");
    System.out.println(newMap.size());

    for(String item : newMap.keySet()){
        System.out.println(item + " "+newMap.get(item));

    }

Answer 1

你不能用一张地图来做这件事，但你可以用它的抽象来做一些事情。

这是一个与 Java 8 兼容的示例；使用两个映射，我们能够保持完整的标签何时将特定键输入映射并基于键递增。假设这是在一个单独的类中定义的。

Map<K, V> newMap = new LinkedHashMap<>();
Map<K, Integer> newMapOccurrences = new HashMap<>();

public void put(K key, V value) {
    newMap.put(key, value);
    newMapOccurrences.put(key, newMapOccurrences.getOrDefault(key, 0) + 1);
}

public Integer getCount(K key) {
    return newMapOccurrences.getOrDefault(key, 0);
}

如果您想确保跟踪键值对，那就有点棘手了，因为不建议使用映射作为键条目。此外，由于 map 无论如何都与键无关，因此尝试同时跟踪两者并不是最好的主意，而且您可能会得到一个错误的计数。但是，我确实以Map<String, Map<String, Integer>>> 的形式提供了一个想法，可能让您在该努力中朝着正确的方向开始；但是，我把它留给读者作为练习。

Answer 2

做到这一点的一种方法是保留一个 Map 来跟踪您为 K 类型的给定键调用 map.put() 的次数。

如果您希望 put 操作自动为您跟踪，您可以拥有一个扩展 LinkedHashMap 的新 Map 类。然后，put 操作将跟踪插入计数，例如

public class KeyCountMap<K,V> extends LinkedHashMap<K,V> {
  private HashMap<K, Integer> keyCountMap;

  public KeyCountMap() {
    this.keyCountMap = new HashMap<K, Integer>();
  }

  @Override
  public V put(K key, V value) {
    keyCountMap.put(key, keyCountMap.getOrDefault(key, 0) + 1);
    return super.put(key, value);
  }

  public int fetchKeyCount(K key) {
    return keyCountMap.getOrDefault(key, 0);
  }
}

使用此映射，您可以通过调用 fetchKeyCount 来获取您的密钥插入计数，例如

  KeyCountMap<String, String> newMap = new KeyCountMap<>();
  newMap.put("aaa", "bbb");
  newMap.put("ccc", "ddd");
  newMap.put("eee", "fff");
  newMap.put("aaa", "bbb");
  System.out.println(newMap.fetchKeyCount("aaa"));

编辑：修改每个 cmets 的代码以删除本地 LinkedHashMap 字段并添加 Java 8 getOrDefault 方法。

Answer 3

public final class PutCountingLinkedHashMap<K, V> extends LinkedHashMap<K, V> {
    private final Map<K, Integer> putCounts = new HashMap<>();

    @Override
    public V put(final K key, final V value) {
        final int count = count(key);
        putCounts.put(key, count + 1);
        return super.put(key, value);
    }

    public int count(final K key) {
        return putCounts.getOrDefault(key, 0);
    }

    public int totalDuplicatePuts() {
      int total = 0;
        for (int i : putCounts.values()) {
            if (i > 1) total += i - 1;
        }
        return total;
    }
}

用法：

PutCountingLinkedHashMap<String,String> map = new PutCountingLinkedHashMap<>();
map.put("aaa", "bbb");
map.put("ccc", "ddd");
map.put("eee", "fff");
map.put("aaa", "bbb");

int aaaCount = map.count("aaa"); //2

需要额外的工作来决定如何处理 remove 或 clear 等的计数。

我正在尝试计算我在地图中输入重复键值对的次数

map.totalDuplicatePuts();

Answer 4

我建议编写您的自定义“HashMap”类，它应该实现 Comparable 接口，然后在调用 super.put(k) 之前覆盖应该使用自定义 compareTo(o) 实现的 put(k,v) 方法,v)。这是一个例子：

    public class MyMap<K,V> extends HashMap<K,V> implements Comparable<Object>{

        @Override
        public V put(K key, V value){

            //Use your custom compareTo method to see if the key already exist, before the HasMap class does it.
            if(compareTo(key) != 0){
                super.put(key, value);
                return value;
            }else{
                //Do something else
            }
            return null;
        }

        @Override
        public int compareTo(Object o) {
            //Implement your desire logic to compare
            //Test if the o object is an instance of desired class
            for(K item : this.keySet()){
                if(o.equals(item))
                    return 0;
            }
            return -1;
        }
    }