Question

想象一下，我有一个名为SortBy枚举的域对象，以便于对服务和/或dao层中的数据进行排序。

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，这是不好的做法（对吧？）。

Item类中的Map<SortBy, Comparator<Item>？
使用方法ItemComparators？

getComparator(Item.SortBy sort)

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 - 安全比较。我不确定第三方库可能提供哪些，但您可以轻松地自己实现它们。以下是我们内部库中的两个：

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;
    }
}

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

3 个答案: