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<String, Map<String, Integer>>>的形式提供了一个想法，可以让你在这一努力中朝着正确的方向着手;但是，我把它作为读者的练习。

Answer 2

执行此操作的一种方法是保留一张地图，该地图会跟踪您为类型K的指定键调用map.put()的次数。

如果您希望put操作为您自动跟踪，则可以使用扩展LinkedHashMap的新Map类。然后，放置操作将跟踪插入计数，例如

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"));

编辑：修改每条评论的代码以删除本地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

我建议您编写自定义＆＃34; HashMap＆＃34; class，它应该实现Comparable接口，然后覆盖put（k，v）方法，在调用super.put（k，v）之前应该使用自定义compareTo（o）实现。这是一个例子：

    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;
        }
    }

比较hastable和equals

4 个答案: