從 JAVA 中的 hashmap 中移除最小的 k 個元素

Question

我有一個 hashmap 的對象。 每個 object 都有兩個屬性（比如說 int 長度和 int 重量）。 我想刪除長度最小的 k 個元素。 這樣做的有效方法是什么？

Answer 1

Map<K, V> map = new HashMap<>();

...

Set<K> keys = map.keySet();
TreeSet<K> smallest = new TreeSet<>(new Comparator<K>(){
    public int compare(K o1, K o2) {
        return o1.getLength() - o2.getLength();
    }
});
smallest.addAll(keys);
for(int x = 0; x < num; x++) {
    keys.remove(smallest.pollFirst());
}

其中K是您的鍵類型， V是您的值類型， num是您要刪除的元素數。

如果您經常這樣做，首先使用TreeMap可能是個好主意。

Answer 2

最簡單但肯定不是最有效的是創建一個TreeMap的實例，其中包含為您的類型提供的Comparator ，從您的 map 到您剛剛創建的 map 的 putAll() 元素，並在keySet()的幫助下刪除 k 元素。 最終 TreeMap 將不包含最小的 k 個元素。

Answer 3

您沒有提到您區分的屬性是鍵還是值的一部分，如果它是鍵，那么上面討論的樹圖是適用的。

否則，如果你需要經常這樣做，我會傾向於實現我自己的 map，將 map 接口中的所有內容委托給 hashmap（或適當的結構 0。覆蓋添加/刪除和必要時的迭代器，然后使用添加/刪除來維護值的排序列表。

這顯然假設值不會改變並且與您的問題高度相關。

Answer 4

請記住，TreeMap 按其鍵的自然順序排序。 因此，您可以根據其值的長度創建具有可比性的鍵。 例如（因為我在吃午餐，所以代碼並不完美，但應該可以滿足您的需求）：

package com.trip.test;    

import java.util.SortedMap;    
import java.util.TreeMap;    

import org.slf4j.Logger;    
import org.slf4j.LoggerFactory;    

public class ComparisonTest {    

private static Logger logger = LoggerFactory.getLogger(ComparisonTest.class);    

private static String[] a = {"1","2","3","4"};    
private static String[] b = {"A","B","D"};    
private static String[] c = {"1","B","D","1","B","D"};    
/**    
 * @param args    
 */    
static SortedMap<KeyWithLength, String[]> myMap = new TreeMap<KeyWithLength, String[]>();    

static {    

        myMap.put(new KeyWithLength("a", a.length), a);    
        myMap.put(new KeyWithLength("b", b.length), b);    
        myMap.put(new KeyWithLength("c", c.length), c);             
}    

public static void main(String[] args) {    

    // print Map    
    logger.info("Original Map:");    

    int i = 0;    
    for (String[] strArray: myMap.values() ){    
        logger.info(String.format("*** Entry %s: ", i++));    
        printStrings(strArray);    
    }    

    // chop off 2 shortest    
    chopNShortest(myMap, 2);    

    // print Map    
    logger.info("ShortenedMap:");    

    i = 0;    
    for (String[] strArray: myMap.values() ){    
        logger.info(String.format("*** Entry %s: ", i++));    
        printStrings(strArray);    
    }    

}    

static void printStrings(String[] strArray){    
    StringBuffer buf = new StringBuffer();    

    for (String str: strArray){    
        buf.append(String.format("%s, ", str));    
    }    
    logger.info(buf.toString());    
}    

static void chopNShortest(SortedMap<KeyWithLength, String[]> sortedMap, int n) {    
    // Assuming map is not unmodifiable    
    if (n <= sortedMap.size()-1){    
        for (int i = 0; i< n;i++){    
            sortedMap.remove(sortedMap.firstKey());    
        }    
    }    
}    

}    

class KeyWithLength implements Comparable<KeyWithLength> {    
private String key;    
private Integer length;    

public KeyWithLength(String key, int length) {    
    super();    
    this.key = key;    
    this.length = length;    
}    

public String getKey() {    
    return key;    
}    

public int getLength() {    
    return length;    
}    

@Override    
public int hashCode() {    
    final int prime = 31;    
    int result = 1;    
    result = prime * result + ((key == null) ? 0 : key.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;    
    KeyWithLength other = (KeyWithLength) obj;    
    if (key == null) {    
        if (other.key != null)    
            return false;    
    } else if (!key.equals(other.key))    
        return false;    
    return true;    
}    

@Override    
public int compareTo(KeyWithLength another) {    
    // TODO Auto-generated method stub    
    return compare(this.length, another.length);    
}    

    public static int compare(int x, int y) {    
        return (x < y) ? -1 : ((x == y) ? 0 : 1);    
    }    

}

output：

Original Map:
*** Entry 0: 
A, B, D, 
*** Entry 1: 
1, 2, 3, 4, 
*** Entry 2: 
1, B, D, 1, B, D, 

ShortenedMap:
*** Entry 0: 
1, B, D, 1, B, D,