是否有一种通过枚举实现多个比较器的好方法？

Question

假设我有一个名为SortBy的域对象，以方便从服务和/或道层对数据进行排序。

public class Item {
    public static enum SortBy { CATEGORY, NORWEGIAN, ENGLISH; }

    private String category;
    private String norwegian;
    private String English;
}

因此，这类操作是可能的：itemDao.getItems(Item.SortBy.CATEGORY)

现在，是否有一种将SortBy值与java Comparator值关联起来的设计模式或好方法？

我问这个问题，因为我最初认为使用static的方式，这是不好的做法(对吗？)

1. 项目类中的Map<SortBy, Comparator<Item>？
2. 一类具有getComparator(Item.SortBy sort)方法的getComparator(Item.SortBy sort)类
3. SortBy枚举本身上返回Comparator<Item>静态实例的方法

我正在寻找一种极简主义的方法来做到这一点，甚至没有一个ItemComparatorProvider bean。

感谢你提供的任何信息..。

Answer 1

最简单的方法就是让enum本身实现Comparator。

public enum SortBy implements Comparator<Item> {
    CATEGORY {
        @Override
        public final int compare(final Item o1, final Item o2) {
            return compareStrings(o1.getCategory(), o2.getCategory());
        }
    },
    ENGLISH {
        @Override
        public final int compare(final Item o1, final Item o2) {
            return compareStrings(o1.getEnglish(), o2.getEnglish());
        }
    },
    NORWEGIAN {
        @Override
        public final int compare(final Item o1, final Item o2) {
            return compareStrings(o1.getNorwegian(), o2.getNorwegian());
        }
    };

    private static int compareStrings(final String s1, final String s2) {
        if (s1 == null) {
            return s2 == null ? 0 : -1;
        }
        if (s2 == null) {
            return 1;
        }
        return s1.compareTo(s2);
    }
}

不需要进一步将每个枚举成员与比较器关联，因为枚举成员是比较器。然后，它的用法很好，也很简洁：

Collections.sort(items, SortBy.CATEGORY);

增编

在下面的注释中，您询问了常见的null-safe比较。我不知道第三方库可以提供什么，但是您可以自己实现它们。以下是我们的一个内部图书馆的两个：

static <T extends Comparable<? super T>> int compare(final T o1, final T o2) {
    if (o1 == null) {
        return o2 == null ? 0 : -1;
    }
    if (o2 == null) {
        return 1;
    }
    return o1.compareTo(o2);
}

@SuppressWarnings("unchecked")
static int compare(final Object a, final Object b) {
    if (a == b) {
        return 0;
    }

    if (a == null) {
        return -1;
    }

    if (b == null) {
        return 1;
    }

    final Class<?> aClass = a.getClass();
    final Class<?> bClass = b.getClass();

    if (Comparable.class.isInstance(a) && aClass.isAssignableFrom(bClass)) {
        return ((Comparable<Object>)a).compareTo(b);
    }

    if (Comparable.class.isInstance(b) && bClass.isAssignableFrom(aClass)) {
        return ((Comparable<Object>)b).compareTo(a);
    }

    throw new IllegalArgumentException("Values must be comparable.");
}

Answer 2

你可以想想这样的事情：

public static enum SortBy {

 CATEGORY(new CategoryComparator()), NORWEGIAN(new NorwegianComparator()), ENGLISH(new EnglishComparator());

    Comparator<Item> comparator;

    private SortBy(Comparator<Item> comparator) {
        this.comparator = comparator;
    }

}

如果要在其他地方使用这些类，可以实现Comparator并创建新类，也可以将它们实现为匿名内部类，如vikingsteve的答案中所示。

Answer 3

好的，这里有一种方法。这样行吗？

public static enum SortBy {
    CATEGORY(new Comparator<Item>() {
        @Override
        public int compare(Item o1, Item o2) {
            return o1.getCategory().compareTo(o2.getCategory());
        }
    }),
    NORWEGIAN(new Comparator<Item>() {
        @Override
        public int compare(Item o1, Item o2) {
            return o1.getNorwegian().compareTo(o2.getNorwegian());
        }
    }),
    ENGLISH(new Comparator<Item>() {
        @Override
        public int compare(Item o1, Item o2) {
            return o1.getEnglish().compareTo(o2.getEnglish());
        }
    });
    private Comparator<Item> comparator;

    private SortBy(Comparator<Item> comparator) {
        this.comparator = comparator;
    }

    public Comparator<Item> getComparator() {
        return comparator;
    }
}