Java 集合排序比较/可比

我试着按姓名的字母顺序倒序排序，然后按年龄升序排序

我可以按姓名的相反顺序排序，但无法按年龄的升序再次排序

PerId Name Age
--------------
7   Simpson 8
3   Michel  10
9   Mark    35
2   Mark    30
8   Lee     40
1   Jorge   19
5   Frank   28
6   Bill    34
4   Bill    16

我的代码

class Util {
    public static List<Person> getPersons() { 
        List<Person> col = new ArrayList<Person>(); 
        col.add(new Person(5, "Frank", 28)); 
        col.add(new Person(1, "Jorge", 19)); 
        col.add(new Person(6, "Bill", 34)); 
        col.add(new Person(3, "Michel", 10)); 
        col.add(new Person(7, "Simpson", 8)); 
        col.add(new Person(4, "Bill",16 )); 
        col.add(new Person(8, "Lee", 40)); 
        col.add(new Person(9, "Mark", 35));
        col.add(new Person(2, "Mark", 30)); 
        return col; 
    } 
}

class Person implements Comparator<Person> { 
    private int perId; 
    private String name; 
    private int age;

    public Person(){}

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

    //.... getters/setters

    @Override
    public int compare(Person e1, Person e2) {
        return e2.getName().compareTo(e1.getName());
    }
}

class PersonId implements Comparable<Person>{
    private Integer perId;

    @Override
    public int compareTo(Person o) {
        return this.perId.compareTo(o.getPerId());
    }
    //...getter
}

public class TestPersonSort {
    public static void main(String[] args) {
        List<Person> coll = Util.getPersons(); 
        Collections.sort(coll, new Person()); 
        // sort method 
        printList(coll);

        //problem here ***********************************************
        //Collections.sort(coll); 
    } 
    private static void printList(List<Person> list) { 
        System.out.println("PerId\tName\tAge"); 
        for (Person e: list) { 
            System.out.println(e.getPerId() + "\t" + e.getName() + "\t" + e.getAge()); 
        }
    }
}

class-Util{
公共静态列表getPersons（）{
List col=new ArrayList（）；
col.add（新成员（5，“Frank”，28））；
col.add（新成员（1，“Jorge”，19））；
加叙（新的人（6，“法案”，34））；
col.add（新人物（3，“Michel”，10））；
上校加（新人（7，“辛普森”，8））；
col.add.（新人员（4，“法案”，16））；
加上校（新人（8，“李”，40））；
col.add（新成员（9，“Mark”，35））；
col.add（新人员（2，“标记”，30））；
返回列；
} 
}
类Person实现比较器{
私人时期；
私有字符串名称；
私人互联网；
公众人物（）{}
公众人物（整数周、字符串名、整数年龄）{
this.perId=perId；
this.name=名称；
这个。年龄=年龄；
}
//…接受者/接受者
@凌驾
公共整数比较（人员e1、人员e2）{
返回e2.getName（）.compareTo（e1.getName（））；
}
}
类PersonId实现了可比较的{
私有整数周长；
@凌驾
公共内部比较（o人）{
将此.perId.compareTo返回（o.getPerId（））；
}
//…吸气剂
}
公共类TestPersonSort{
公共静态void main（字符串[]args）{
List coll=Util.getPersons（）；
Collections.sort（coll，newperson（））；
//排序方法
打印列表（coll）；
//这里有问题***********************************************
//Collections.sort（coll）；
} 
私有静态无效打印列表（列表列表）{
System.out.println（“PerId\tName\tAge”）；
（e人：名单）{
System.out.println（e.getPerId（）+“\t”+e.getName（）+“\t”+e.getAge（））；
}
}
}

使用

比较器

类首先比较此人的姓名。如果比较不是

0

，则返回它。如果是

0

，则继续比较此人的年龄

public int compare(Person e1, Person e2) {
    int comp = e2.getName().compareTo(e1.getName());  // desc
    if (comp != 0) return comp;
    return e1.getAge() - e2.getAge();  // asc
}

另一个更复杂但更灵活的选项是使用其他

比较器的
比较器
。然后，您可以在
列表中提供比较每个属性的
比较器
，以组合它们的效果

public class FlexiblePersonComparator implements Comparator<Person>
{
   private List<Comparator<Person>> comparators;

   public FlexiblePersonComparator(List<Comparator<Person>> comparators)
   {
      this.comparators = comparators;
   }

   @Override
   public int compare(Person p1, Person p2)
   {
      int comp;
      for (Comparator<Person> comparator : comparators)
      {
         comp = comparator.compare(p1, p2);
         if (comp != 0)
            return comp;
      }
      return 0;
   }
}

公共类FlexiblePersonComparator实现Comparator
{
私人名单比较国；
公共FlexiblePersonComparator（列表比较器）
{
这个。比较器=比较器；
}
@凌驾
公共整数比较（人员p1、人员p2）
{
国际公司；
for（比较器比较器：比较器）
{
comp=比较器比较（p1，p2）；
如果（组件！=0）
返回补偿；
}
返回0；
}
}
一个简单的方法是让
人员实施
可比的
main（）
然后可以使用

class Person实现可比较的{
私人时期；
私有字符串名称；
私人互联网；
公众人物（）{}
公众人物（整数周、字符串名、整数年龄）{
this.perId=perId；
this.name=名称；
这个。年龄=年龄；
}
//…接受者/接受者
@凌驾
公共int比较（其他人）{
int结果；
如果（其他==null）
返回（0）；
如果（其他==此）
返回（0）；
结果=name.compareTo（其他.name）；
如果（结果！=0）
return（-result）；//对名称进行反向排序
return（age-other.age）；//按升序排序
}
}
创建另一个用于按年龄排序的比较器，就像您为name所做的那样，然后将该比较器传递给sort方法。
class Person implements Comparable<Person> { 
    private int perId; 
    private String name; 
    private int age;

    public Person(){}

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

    //.... getters/setters

    @Override
    public int compareTo(Person other) {
        int result;

        if (other == null)
            return(0);

        if (other == this)
            return(0);

        result = name.compareTo(other.name);

        if (result != 0)
            return(-result);    // Sort names in reverse

        return(age - other.age);   // Sort age ascending
    }
}