Java 按最高分对地图排序

我有一张地图，上面有球员的名字和分数，我可以在上面更新，一切都很好

public static Map<String, Integer> map = new HashMap<String, Integer>();

publicstaticmap=newhashmap（）；

第一轮比赛结束后，我想从地图上删除最低分数。例如，地图上可能有8名球员，其中4名得分为10，其他4名得分为0。我如何根据得分最高的球员将地图分成两半，并删除得分最低的4名球员？请记住，8名玩家没有定义，它可以是我发现可能有用的任何数字。一个是不能对Hashmap进行排序，因为它没有确定的顺序。如果你想通过LinkedHashMap进行排序，这就是你的方法。（LinkedHashMap只有一个确定的迭代顺序）

另一方面，如果您想删除最小值，我怀疑这是最简单的方法，您可以这样做来对它们进行排序

public static Entry<String, Integer> removeLowest(LinkedHashMap<String, Integer> map){
    Entry<String, Integer> lowest = null;
    for(Entry<String,Integer> e: map){
        if(lowest==null || e.getValue().compareTo(lowest.getValue()) < 0){
            lowest = e;
        }
    }
    return lowest;
}

publicstaticentry removeLowest（LinkedHashMap映射）{
条目下限=空；
用于（条目e：地图）{
if（lovel==null | | e.getValue（）.compareTo（lovel.getValue（））<0）{
最低=e；
}
}
回报率最低；
}

附言：如果我的回答对你有效，别忘了接受

更新：如果你想移除地图的一半。你可以先把它分类，然后再这样做

public static LinkedHashMap<String, Integer> getTopHalf(LinkedHashMap<String, Integer> map){
    LinkedHashMap<String, Integer> sorted = sortHashMapByValues(map);
    LinkedHashMap<String, Integer> out = new LinkedHashMap<String, Integer>();
    Iterator<Entry<String,Integer>> it = sorted.entrySet().iterator();
    for(int i = 0;  i<map.size()/2; i++){
        Entry<String, Integer> e = it.next();
        out.put(e.getKey(), e.getValue());
    }
    return out;
}

public静态LinkedHashMap getTopHalf（LinkedHashMap映射）{
LinkedHashMap排序=sortHashMapByValues（映射）；
LinkedHashMap out=新建LinkedHashMap（）；
迭代器it=sorted.entrySet（）.Iterator（）；
对于（inti=0；i，有一种更简单的方法

您可以在TreeMap上使用自定义分类器算法。
例如：TreeMap map=newtreemap（您自己的比较器）

您可以编写自己的比较器来实现比较器接口

示例（摘自StackOverflow，不知道得更准确）：

类ValueComparator实现Comparator{

Map<String, Integer> base;
public ValueComparator(Map<String, Integer> base) {
    this.base = base;
}

public int compare(String a, String b) {
    if (base.get(a) >= base.get(b)) {
        return -1;
    } else {
        return 1;
    } // returning 0 would merge keys
}

地图库；
公共价值比较器（地图库）{
this.base=base；
}
公共整数比较（字符串a、字符串b）{
如果（base.get（a）>=base.get（b））{
返回-1；
}否则{
返回1；
}//返回0将合并密钥
}

}

然后，您只需按升序编辑此代码，然后只需从中删除前X.元素。
似乎没有人注意到这不是映射。如果您查看高分，名称可能会重复。您需要的是NavigableSet

class HighScore implements Comparable<HighScore> {
    private static final AtomicLong NEXT_ID = new AtomicLong(1);

    protected final String name;
    protected final long id = NEXT_ID.getAndIncrement();
    protected final int score;

    // ...

    public int compareTo(HighScore o) {
        int diff = score - o.score;
        if (diff != 0) { return diff; }

        long idDiff = id - o.id;
        if (idDiff < 0) { return -1; }
        else if (idDiff > 0) { return 1; }
        else { return 0; }
    }
}

class HighScore实现了可比性{
private static final AtomicLong NEXT_ID=new AtomicLong（1）；
受保护的最终字符串名称；
受保护的最终长id=NEXT_id.getAndIncrement（）；
受保护的最终整数分数；
// ...
公共int比较（高分o）{
int diff=分数-o分数；
如果（diff！=0）{返回diff；}
长idDiff=id-o.id；
if（idDiff<0）{return-1；}
else如果（idDiff>0）{返回1；}
else{return 0；}
}
}

然后您可以只
pollFirst（）
删除。下面是可能对您有所帮助的内容。我使用相同的键和值值填充了映射，以查看打印时的顺序。下面的示例包括


获取上半部分视图而不从原始地图中删除下半部分的方法
并从原始地图中删除下半部分

除非要求删除，否则不需要删除下半部分，仍然可以获取原始地图支持的headMap

import java.util.NavigableMap;
import java.util.TreeMap;

public class HalfTheMap {

    static void addValues(TreeMap<String, Integer> map)
    {
        map.put("11", 11);
        map.put("33", 33);
        map.put("77", 77);
        map.put("44", 44);
        map.put("55", 55);
        map.put("22", 22);
        //map.put("66", 66);
    }

    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<String, Integer>();
        addValues(map);
        System.out.printf("Original Map Initial Values : %s\n",map);

        int size = map.size();
        int midIndex = (size/2) - 1;
        System.out.printf("size : %d \nmid : %d\n", size, midIndex);

        // retrieve key of middle element
        String midKey = (String)map.keySet().toArray()[midIndex];

        // Top half view of the original map
        NavigableMap<String, Integer> topMap = map.headMap(midKey, true);
        System.out.printf("Top half map : %s\n",  topMap);

        // remove the bottom half from original map.
        map.tailMap(midKey, false).clear();
        System.out.printf("Original map after bottom half removed : %s\n", map);
    }

}

我留下的微调减半时，大小是奇数值给你和任何其他微调，是适合你的需要

注意：我注意到我的示例在每个条目中使用相同值的键和值似乎表明它可能是一个解决方案，事实上并不完全如此。尽管它演示了一些重要方法的使用来解决问题。
正如上面David Ehrmann所回答的，将集合更改为Set而不是Map，并使用具有模态名称和分数的类可能是更好的解决方案

希望这能有所帮助。
如果你需要排序，也许一个
TreeMap
会比一个
HashMap
更好？我用一个树形图试过，可以得到得分最高的前2、3等。我只是不知道如何根据这些得分得到上半部分。也许通过按分数排序，然后迭代得到上半部分？但是如果有两个以上的球员，我想找到得分最高的那一半，然后去掉另一半，或者把上半部分放到一张新地图上。去掉下半部分是我的问题
import java.util.NavigableMap;
import java.util.TreeMap;

public class HalfTheMap {

    static void addValues(TreeMap<String, Integer> map)
    {
        map.put("11", 11);
        map.put("33", 33);
        map.put("77", 77);
        map.put("44", 44);
        map.put("55", 55);
        map.put("22", 22);
        //map.put("66", 66);
    }

    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<String, Integer>();
        addValues(map);
        System.out.printf("Original Map Initial Values : %s\n",map);

        int size = map.size();
        int midIndex = (size/2) - 1;
        System.out.printf("size : %d \nmid : %d\n", size, midIndex);

        // retrieve key of middle element
        String midKey = (String)map.keySet().toArray()[midIndex];

        // Top half view of the original map
        NavigableMap<String, Integer> topMap = map.headMap(midKey, true);
        System.out.printf("Top half map : %s\n",  topMap);

        // remove the bottom half from original map.
        map.tailMap(midKey, false).clear();
        System.out.printf("Original map after bottom half removed : %s\n", map);
    }

}

Original Map Initial Values : {11=11, 22=22, 33=33, 44=44, 55=55, 77=77}
size : 6 
mid : 2
Top half map : {11=11, 22=22, 33=33}
Original map after bottom half removed : {11=11, 22=22, 33=33}