使用不同的键对列表进行排序

Question

这里的极端新手正在努力掌握列表排序的所有不同方式。假设我有一个对象列表，每个对象都有几个键，可用于在不同情况下进行排序。我从这个线程中得到了一些非常有用的信息： Java Interface Comparator static compare, 使用 Qwerky 的第一个示例作为创建的模型：

class Dog {
   private String name;
   private int age;
   private int height;
   private int weight;

   Dog(String n, int a, int b, int c){
      name = n;
      age = a;
      height = b;
      weight = c;
   }
   public String getDogName(){
      return name;
   }
   public int getDogAge(){
      return age;
   } 
   public int getDogHeight(){
      return height;
   }
   public int getDogWeight(){
      return weight;
   }
}

class DogComparator1 implements Comparator<Dog> {
   @Override
   public int compare(Dog d, Dog d1){
      return d.getDogAge() - d1.getDogAge();
   }
}
   class DogComparator2 implements Comparator<Dog> {
   @Override
   public int compare(Dog d, Dog d1){
      return d.getDogHeight() - d1.getDogHeight();
   }
}
   class DogComparator3 implements Comparator<Dog> { 
   @Override
   public int compare(Dog d, Dog d1){
      return d.getDogWeight() - d1.getDogWeight();
   }
}


public class Example{

   public static void main(String args[]){
      // Creat list of dog objects
      List<Dog> dogList = new ArrayList<>();

      // Add a buch of dogs to the list here
               .
               .

      // Create the Comparators
      DogComparator1 compare1 = new DogComparator1();
      DogComparator2 compare2 = new DogComparator2();
      DogComparator3 compare3 = new DogComparator3();


      // Sort the list using Comparators
      Collections.sort(list, compare1);  // Sort by age     
      Collections.sort(list, compare2);  // Sort by height
      Collections.sort(list, compare3);  // Sort by weight          
   }
}

但是，这似乎不对。我想我想将比较器定义拉到 Dog class“内部”以很好地封装它们。但是，不知道怎么做。

我走在正确的轨道上吗？如果是这样，将不胜感激帮助正确的语法。

Answer 1

你绝对是在正确的轨道上。

我会把这个添加到你的 Dog class:

public static final Comparator<Dog> COMPARE_BY_AGE = new Comparator<Dog>() {
    @Override
    public int compare(Dog d, Dog d1) {
        return d.getDogAge() - d1.getDogAge();
    }
};

public static final Comparator<Dog> COMPARE_BY_HEIGHT = new Comparator<Dog>() {
    @Override
    public int compare(Dog d, Dog d1) {
        return d.getDogHeight() - d1.getDogHeight();
    }
};

public static final Comparator<Dog> COMPARE_BY_WEIGHT = new Comparator<Dog>() {
    @Override
    public int compare(Dog d, Dog d1) {
        return d.getDogWeight() - d1.getDogWeight();
    }
};

然后用法如下：

    // Sort the list using Comparators
    Collections.sort(list, Dog.COMPARE_BY_AGE);  // Sort by age
    Collections.sort(list, Dog.COMPARE_BY_HEIGHT);  // Sort by height
    Collections.sort(list, Dog.COMPARE_BY_WEIGHT);  // Sort by weight

Answer 2

我不认为 Dog class 有责任了解您可以比较它的不同方式。但是，您可以将这些比较器创建为内部 classes，如果这会让您感觉更 "encapsulated"（甚至将此 class 设为私有）。

即你可以在 Dog class 中这样做：

public class Dog {

(...)

    public Comparator<Dog> getAgeComparator() {
        return new AgeComparator();
    }

    private static class AgeComparator implements Comparator<Dog> {
       @Override
       public int compare(Dog d, Dog d1){
          return d.getDogAge() - d1.getDogAge();
       }
}

或者，不是创建 getAgeComparator() 方法，而是将这些比较器公开为：

public static final Comparator<Dog> AGE_COMPARATOR = new AgeComparator();

您也可以在那里创建匿名实现。你这样做的方式是正确的。我不会让 Dog 知道如何比较它。您可以轻松地在其他地方使用这些实现，或者如果您不重用它们，甚至可以即时创建匿名 class 实现。你想实现的是对封装的错误理解。

您可以创建默认比较器，方法是使 Dog class 实现 Comparable<Dog>:

public class Dog implements Comparable<Dog> {

    public int compareTo(Dog dog) {
        return AGE_COMPARATOR.compare(this, dog); // or inline comparison here
    }

    (...)
}

Answer 3

考虑使用 Comparator#comparingInt 创建比较器：

  list.sort(Comparator.comparingInt(Dog::getDogAge));  // Sort by age     
  list.sort(Comparator.comparingInt(Dog::getDogHeight));  // Sort by height
  list.sort(Comparator.comparingInt(Dog::getDogWeight));  // Sort by weight

这种方式使您不必像现在这样编写自己的 Comparator<Dog> 实现，并且很容易准确地看到正在比较的内容。

因为 Comparator 已经只使用了 Dog 的 public 方法，而且它们这么短，所以没有太多理由将它们封装在 Dog 中.

使用不同的键对列表进行排序

Sort List Using Different Keys

java

sorting

object