Java 如何根据值（即具有多个属性的对象）对地图进行排序

我有一个非常直截了当的代码，可以根据值而不是键对HashMap进行排序（从SO复制而来，但例如on SO只是对字符串进行排序，而as我想根据对象的属性进行排序）

import java.util.Collections；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.LinkedHashMap；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
公共类SortMapByValue
{
公共静态布尔值ASC=true；
公共静态布尔DESC=false；
公共静态void main（字符串[]args）
{
个人=新人（21，“约翰”，174，“能源部”）；
Person persontw=新人（19，“迈克尔”，154，“乔丹”）；
Person persontree=新人（22，“大卫”，184，“太阳”）；
Person personFour=新人（23，“伊恩”，164，“米勒”）；
//创建虚拟未排序贴图
Map unsortMap=newhashmap（）；
不排序地图。放置（“B”，人称）；
unsortMap.put（“A”，personTwo）；
放在树上（“D”，人称树）；
不排序图。放（“C”，第四人称）；
System.out.println（“排序前……”）；
printMap（unsortMap）；
System.out.println（“升序排序后……”）；
Map sortedMapAsc=排序比较程序（unsortMap，ASC）；
印刷地图（分类地图）；
System.out.println（“排序后定义顺序……”）；
Map sortedMapDesc=sortByComparator（反排序图，DESC）；
打印地图（sortedMapDesc）；
}
私有静态映射sortByComparator（映射非排序映射，最终布尔顺序）
{
List=新的LinkedList（unsortMap.entrySet（））；
//根据值对列表进行排序
Collections.sort（list，newcomparator（）
{
@凌驾
公共整数比较（条目o1、条目o2）
{
如果（订单）
{
返回o1.getValue（）.compareTo（o2.getValue（））；
}
其他的
{
返回o2.getValue（）.compareTo（o1.getValue（））；
}
}
});
//借助LinkedList维护插入顺序
Map sortedMap=new LinkedHashMap（）；
用于（条目：列表）
{
sortedMap.put（entry.getKey（），entry.getValue（））；
}
返回分拣的DMAP；
}
公共静态无效打印地图（地图地图）
{
for（条目：map.entrySet（））
{
System.out.println（“Key:+entry.getKey（）+”Value:+entry.getValue（）.getName（））；
}
}
}

这是Person类：

public class Person implements Comparable{

    private int age;
    private String name;
    private int height;
    private String lastname;

    public Person(int age, String name, int height, String lastname) {
        this.age = age;
        this.name = name;
        this.height = height;
        this.lastname = lastname;
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    @Override
    public int compareTo(Object arg0) {
        Person country=(Person) arg0;
        return (this.getAge() < country.getAge() ) ? -1: (this.getAge() > country.getAge() ) ? 1:0;
    }        

}

公共类人员实现可比较{
私人互联网；
私有字符串名称；
私人内部高度；
私有字符串lastname；
公众人物（整数年龄、字符串名称、整数高度、字符串姓氏）{
这个。年龄=年龄；
this.name=名称；
高度=高度；
this.lastname=lastname；
}
公共整数getAge（）{
回归年龄；
}
公共无效设置（整数）{
这个。年龄=年龄；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共整数getHeight（）{
返回高度；
}
公共空间设置高度（内部高度）{
高度=高度；
}
公共字符串getLastname（）{
返回姓氏；
}
public void setLastname（字符串lastname）{
this.lastname=lastname；
}
@凌驾
公共整数比较对象（对象arg0）{
个人国家=（个人）arg0；
return（this.getAge（）country.getAge（））？1:0；
}        
}

---

现在，如果将代码复制粘贴到IDE中，您将看到映射中的值都是基于年龄排序的，因为Person类以仅基于年龄比较对象的方式重写了compareTo方法。现在有没有一种方法可以让这更具活力。例如，我可以更改进行比较的值，例如，假设我也想基于名称、高度和姓氏进行比较

您的

sortByComparator

方法创建了一个依赖于Person类的

Comparator

实现的

Comparator

。相反，您可以将任何

比较器

传递给您的

排序比较器

，每个传递的

比较器

都可以按不同的标准排序

private static Map<String, Person> sortByComparator(Map<String, Person> unsortMap, Comparator<Person> cmp, final boolean order)
{

    List<Entry<String, Person>> list = new LinkedList<>(unsortMap.entrySet());

    // Sorting the list based on values
    Collections.sort(list, new Comparator<Entry<String, Person>>()
    {
        @Override
        public int compare(Entry<String, Person> o1, Entry<String, Person> o2)
        {
            if (order)
            {
                return cmp.compare(o1.getValue(),o2.getValue());
            }
            else
            {
                return cmp.compare(o2.getValue(),o1.getValue());
            }
        }
    });

    // Maintaining insertion order with the help of LinkedList
    Map<String, Person> sortedMap = new LinkedHashMap<>();
    for (Entry<String, Person> entry : list)
    {
        sortedMap.put(entry.getKey(), entry.getValue());
    }

    return sortedMap;
}

private static Map sortByComparator（Map unsortMap，Comparator cmp，final boolean order）
{
List=新的LinkedList（unsortMap.entrySet（））；
//根据值对列表进行排序
Collections.sort（list，newcomparator（）
{
@凌驾
公共整数比较（条目o1、条目o2）
{
如果（订单）
{
返回cmp.compare（o1.getValue（），o2.getValue（））；
}
其他的
{
返回cmp.compare（o2.getValue（），o1.getValue（））；
}
}
});
//借助LinkedList维护插入顺序
Map sortedMap=new LinkedHashMap（）；
用于（条目：列表）
{
sortedMap.put（entry.getKey（），entry.getValue（））；
}
返回分拣的DMAP；
}

排序的哈希映射没有意义，它会破坏哈希算法。如果你想要一个被排序的地图，你应该考虑使用一个TreMeP代替。< /P>你不能排序<代码> HashMap < /代码>；它不知道order@fge我说的是提供给我们行为的额外逻辑我当前的逻辑采用以下比较器“new Comparator（）”，我如何进一步发送实现Person类的比较器对象differently@kapilchhattani请参阅我的编辑。您应该向

sortByComparator

传递实现

Comparator

的类的实例，并在比较器中使用该比较器，因为cmp是将作为比较器的对象。。让我来看看

public class Test {
public static void main(String[] args) {
TreeMap<Integer, String> hm=new TreeMap();
hm.put(3, "arun singh");
hm.put(5, "vinay singh");
hm.put(1, "bandagi singh");
hm.put(6, "vikram singh");
hm.put(2, "panipat singh");
hm.put(28, "jakarta singh");

ArrayList<String> al=new ArrayList(hm.values());
Collections.sort(al, new myComparator());

System.out.println("//sort by values \n");
for(String obj: al){
    for(Map.Entry<Integer, String> map2:hm.entrySet()){
        if(map2.getValue().equals(obj)){
            System.out.println(map2.getKey()+" "+map2.getValue());
        }
    } 
 }
}
}

class myComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
     String o3=(String) o1;
     String o4 =(String) o2;
return o3.compareTo(o4);
    }   
}

public class Test {
public static void main(String[] args) {
TreeMap<Integer, String> hm=new TreeMap();
hm.put(3, "arun singh");
hm.put(5, "vinay singh");
hm.put(1, "bandagi singh");
hm.put(6, "vikram singh");
hm.put(2, "panipat singh");
hm.put(28, "jakarta singh");

ArrayList<String> al=new ArrayList(hm.values());
Collections.sort(al, new myComparator());

System.out.println("//sort by values \n");
for(String obj: al){
    for(Map.Entry<Integer, String> map2:hm.entrySet()){
        if(map2.getValue().equals(obj)){
            System.out.println(map2.getKey()+" "+map2.getValue());
        }
    } 
 }
}
}

class myComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
     String o3=(String) o1;
     String o4 =(String) o2;
return o3.compareTo(o4);
    }   
}

//sort by values 

3 arun singh
1 bandagi singh
28 jakarta singh
2 panipat singh
6 vikram singh
5 vinay singh