Java-将不相关的对象与自定义顺序进行比较

Question

我想通过提供自定义顺序对包含不相关对象的列表进行排序。例如，我要排序的列表包含Animal类的对象。动物对象有一个名为type的对象，可以是猫、老鼠或狗。我有一个自定义订单鼠标

// Cat and Mouse are similar 
public class Dog {
    ...
}

public class Animal {
    Object type;

    public Animal(Object aType) {
        type = aType;
    }

    // getter , setter etc.
}

public class Comparison {

       List<Animal> animals;

       public Comparison() {
          Dog dog1 = new Dog();
          Animal animal1 = new Animal(dog);
          animals.add(animal1);
          Cat cat1 = new Cat();
          Animal animal2 = new Animal(cat);
          animals.add(animal2);
          // add other elements of type dog, cat or mouse
          ....
          // sort the list with custom order: mouse<cat<dog
          Collections.sort(animals,intComparator());
       }

    private Comparator<Animal> intComparator() {
        return new Comparator<Animal>() {
          @Override
          public int compare(Animal first, Animal second) {
              return ???;
      }
    };
  }

}

一种解决方案是手动检查类型的类（通过 instanceof）并在比较器中对顺序进行硬编码。但是，我有太多可以包含在 Animal 中的类（在本例中不仅包含三个类），因此这将产生大量的 if 案例。

    private Comparator<Animal> intComparator() {
        return new Comparator<FXNode>() {
          @Override
          public int compare(Animal first, Animal second) {
              // if first is a mouse, return -1 because it is the 'smallest' object
              if (first.getType() instanceof Mouse) return -1;
              // if first is a cat and second a mouse, return 1 etc., a lot of if cases
      }

Answer 1

AFAIK，这完全取决于您如何确定自定义订购。例如，假设您在 Animal 类中有一个 size 属性，那么您将使用该属性来比较比较方法中的大小。如果确定排序的因素不是 Animal 类的属性，则必须按照在代码段中执行此操作的方式对其进行硬编码。

Answer 2

我希望你的例子是糟糕的，你实际上没有这样做，因为这确实是一个糟糕的概念。也许你应该重新考虑你的类层次结构，因为我不明白对不相关的对象进行排序的意义。

因为您留下了＜code＞比较器

public class CustomComparator implements Comparator<FXNode> {
    static Map<Class<? extends FXNode>,Integer> priorities = new HashMap<>();
    static {
        priorities.put(Node1.class,2);
        priorities.put(Node2.class,1);
    }

    @Override
    public int compare(FXNode o1, FXNode o2) {
        return Integer.compare(priorities.get(o1.getClass()),priorities.get(o1.getClass()));
    }   
}

然而，在更一般的情况下，我建议您只比较逻辑上相似并因此共享某些属性或方法的对象。

Answer 3

比如说：

enum Species { Cat, Dog, Mouse, ... };

class Animal {
  Species species;
};

然后对于比较器：

private Comparator<Animal> intComparator() {
  return new Comparator<FXNode>() {
    @Override
    public int compare(Animal first, Animal second) {
      return first.species.compareTo(second.species);
    }
  }
}

该顺序来自< code>enum。你可以附加属性(腿的数量，颜色等。)转换为< code>Species值。请参见Oracle教程。