从 JAVA 中的 hashmap 中移除最小的 k 个元素

Question

I have a hashmap of objects. Each object has two attributes (let say int length and int weight). I want to remove k elements with the smallest length. What is the efficient way of doing this?

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

Where K is your key type, V is your value type, and num is the number of elements you wish to remove.

If you are doing this frequently, it might be a good idea to use aTreeMap in the first place.

Answer 2

The easiest, but certainly not the most efficient is to create an instance of aTreeMap with provided Comparator for your type, putAll() elements from your map to the map you just created and remove k-elements with help of keySet() . In the end a TreeMap will not contain k-smallest elements.

Answer 3

You didn't mention if the attribute you discriminate on is part of the key or the value, if it's the key then teh treemap discussed above is applicbale.

Otherwise If you need to do this often I'd be inclined to implement my own map, delegating everything in the map interface to a hashmap (or appropriate structure0. Override the add/remove and if necessary iterator, then use the add/remove to maintain a sorted list of the values.

This obviously assumes the values don't change and is highly coupled to your problem.

Answer 4

Keep in mind that TreeMap sorts by the natural ordering of its keys. Hence you can create a key with comparable based on the length of it's value. For example (Since I am on Lunch the code isn't perfect but should get you to what you need):

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

}

The 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,