Java 如何制作一个通用的ValueComparator来对多个HashMap进行排序？

我首先开始使用一个HashMap，例如：

private static Map<Broker, Integer> brokerSalesCountList = new HashMap<Broker, Integer>();

private static Map brokersalescontlist=new HashMap（）；

使用

private static ValueComparator4Broker bvc =  new ValueComparator4Broker(brokerSalesCountList);
private static TreeMap<Broker,Integer> sortedbrokerSalesCountList  = new TreeMap<Broker,Integer>(bvc);

sortedbrokerSalesCountList.putAll(brokerSalesCountList);

private static ValueComparator4Broker bvc=新的ValueComparator4Broker（brokersalescontlist）；
私有静态树映射sortedbrokerSalesCountList=新树映射（bvc）；
sortedbrokerSalesCountList.putAll（brokerSalesCountList）；

这是我的值比较器代码：

public class ValueComparator4Broker implements Comparator<Broker> {

    Map<Broker, Integer> base;
    public ValueComparator4Broker(Map<Broker, Integer> base) {
        this.base = base;
    }

    @Override
    public int compare(Broker a, Broker b) {
        if (base.get(a) >= base.get(b)) {
            return -1;
        } else {
            return 1;
        }
    }
}

公共类ValueComparator4Broker实现Comparator{
地图库；
public ValueComparator4Broker（地图库）{
this.base=base；
}
@凌驾
公共整数比较（代理a、代理b）{
如果（base.get（a）>=base.get（b））{
返回-1；
}否则{
返回1；
}
}
}

问题：现在我有两个以上的新哈希映射以相同的方式进行排序，我不想重复ValueComparator4Broker类的代码，我想创建一个通用的参数化ValueComparator类，可供所有新的*HashMap*使用：

private static Map<Area, Integer> areaBrokerCountList = new HashMap<Area, Integer>();
private static Map<Area, Integer> areaSalesTotalList = new HashMap<Area, Integer>();

private static Map areaBrokerCountList=new HashMap（）；
私有静态映射areaSalesTotalList=new HashMap（）；

我尝试了下面的方法，但是代码是错误的，甚至不接受HashMap的key对象来代替Type。如果您能帮助改进方法和代码示例，我们将不胜感激：

import java.lang.reflect.Type;
import java.util.Comparator;
import java.util.Map;

public class ValueComparator implements Comparator<Type> {  
    Map<Type, Integer> base;
    public ValueComparator(Map<Type, Integer> base) {
        this.base = base;
    }

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

}

import java.lang.reflect.Type；
导入java.util.Comparator；
导入java.util.Map；
公共类ValueComparator实现比较器{
地图库；
公共价值比较器（地图库）{
this.base=base；
}
@凌驾
公共整数比较（类型a、类型b）{
如果（base.get（a）>=base.get（b））{
返回-1；
}否则{
返回1；
}//返回0将合并密钥
}
}

我不太擅长冷键入通用代码，但我的想法是：

以这种方式使用该类：

Map<Broker, Integer> brokerSalesCountList = new HashMap<Broker, Integer>();

private static ValueComparator<Broker> bvc =  new ValueComparator<Broker>(brokerSalesCountList);

Map brokersalescontlist=newhashmap（）；
私有静态ValueComparator bvc=新的ValueComparator（brokerSalesCountList）；

在此处定义类：

public class ValueComparator<T> implements Comparator<T> {  
    Map<T, Integer> base;
    public ValueComparator(Map<T, Integer> base) {
        this.base = base;
    }

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

}

公共类ValueComparator实现Comparator{
地图库；
公共价值比较器（地图库）{
this.base=base；
}
@凌驾
公共整数比较（TA，TB）{
如果（base.get（a）>=base.get（b））{
返回-1；
}否则{
返回1；
}//返回0将合并密钥
}
}

比较器必须返回

0

，否则将无法使用生成的

映射。试图将一个值比较器扭曲成一个
TreeMap
显然是个坏主意。试着保存一个已排序的条目集合，或者在对条目进行排序并按顺序插入之后使用
LinkedHashMap
。@Louis，你似乎提出了一个非常宝贵的建议，但是关于“如何”部分，我完全不知道。任何例子都将不胜感激。