Хороший общий способ отсортировать аннулирует к нижней части, независимо?
<div class="name">
<span class="firstname">John</span>
<span class="lastname">Doe</span>
</div>
Это зависит полностью от того, что Вы хотите выразить. Если повышение имени имеет семантическую ценность для Вас (будьте им только для имения рычага для CSS, чтобы отформатировать имена или извлечь их использующий некоторый язык сценариев), тогда можно использовать промежуток.
4 ответа
Последний вариант мне очень нравится. Компараторы действительно здорово соединять вместе. В частности, вы можете захотеть написать ReverseComparator , а также NullWrappingComparator .
РЕДАКТИРОВАТЬ: Вам не нужно писать это самостоятельно. Если вы посмотрите на класс Ordering в Библиотеке коллекций Google , вы найдете это и множество других полезных вещей :)
РЕДАКТИРОВАТЬ: Более подробно, чтобы показать, что я означают о ReverseComparator ...
Одно слово предупреждения - в реализации ReverseComparator измените порядок аргументов вместо отрицания результата, иначе Integer.MIN_VALUE «обратится» самому себе. .
Таким образом, эта реализация неверна (при условии, что исходный является компаратором для обратного преобразования):
public int compare(T x, T y)
{
return -original.compare(x, y);
}
но это верно:
public int compare(T x, T y)
{
return original.compare(y, x);
}
Причина в том, что мы всегда хотим обратить сравнение, но если original.compare (x, y) возвращает int.MIN_VALUE , тогда плохой компаратор также вернет int.MIN_VALUE , то есть неверно. Это связано с забавным свойством int.MIN_VALUE == -int.MIN_VALUE .
Integer.MIN_VALUE «обращено» к самому себе.
Таким образом, эта реализация неверна (предполагая, что исходный является компаратором для обратного):
public int compare(T x, T y)
{
return -original.compare(x, y);
}
но это правильно:
public int compare(T x, T y)
{
return original.compare(y, x);
}
Причина в том, что мы всегда хотим отменить сравнение, но если original.compare (x, y) возвращает int.MIN_VALUE , тогда плохой компаратор также вернет int.MIN_VALUE , что неверно. Это связано с забавным свойством int.MIN_VALUE == -int.MIN_VALUE .
Integer.MIN_VALUE «обращено» к самому себе.
Таким образом, эта реализация неверна (предполагая, что исходный является компаратором для обратного):
public int compare(T x, T y)
{
return -original.compare(x, y);
}
но это правильно:
public int compare(T x, T y)
{
return original.compare(y, x);
}
Причина в том, что мы всегда хотим отменить сравнение, но если original.compare (x, y) возвращает int.MIN_VALUE , тогда плохой компаратор также вернет int.MIN_VALUE , что неверно. Это связано с забавным свойством int.MIN_VALUE == -int.MIN_VALUE .
public int compare(T x, T y)
{
return -original.compare(x, y);
}
, но это правильно:
public int compare(T x, T y)
{
return original.compare(y, x);
}
Причина в том, что мы всегда хотим отменить сравнение, но если original.compare (x, y) возвращает int.MIN_VALUE , тогда плохой компаратор также вернет int.MIN_VALUE , что неверно. Это связано с забавным свойством int.MIN_VALUE == -int.MIN_VALUE .
public int compare(T x, T y)
{
return -original.compare(x, y);
}
, но это правильно:
public int compare(T x, T y)
{
return original.compare(y, x);
}
Причина в том, что мы всегда хотим отменить сравнение, но если original.compare (x, y) возвращает int.MIN_VALUE , тогда плохой компаратор также вернет int.MIN_VALUE , что неверно. Это связано с забавным свойством int.MIN_VALUE == -int.MIN_VALUE .
В продолжение ответа dfa - я хочу, чтобы в конце сортировка нулей не влияла на порядок ненулевых значений. Так что я хочу кое-что еще в этом роде:
public class NullComparatorsTest extends TestCase {
Comparator<String> forward = new Comparator<String>() {
public int compare(String a, String b) {
return a.compareTo(b);
}
};
public void testIt() throws Exception {
List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null);
Collections.sort(strings, NullComparators.atEnd(forward));
assertEquals("[aaa, bbb, ccc, null, null, null]", strings.toString());
Collections.sort(strings, NullComparators.atBeginning(forward));
assertEquals("[null, null, null, aaa, bbb, ccc]", strings.toString());
}
}
public class NullComparators {
public static <T> Comparator<T> atEnd(final Comparator<T> comparator) {
return new Comparator<T>() {
public int compare(T a, T b) {
if (a == null && b == null)
return 0;
if (a == null)
return 1;
if (b == null)
return -1;
return comparator.compare(a, b);
}
};
}
public static <T> Comparator<T> atBeginning(final Comparator<T> comparator) {
return new Comparator<T>() {
public int compare(T a, T b) {
if (a == null && b == null)
return 0;
if (a == null)
return -1;
if (b == null)
return 1;
return comparator.compare(a, b);
}
};
}
}
Тем не менее, полное уважение к dfa - это лишь небольшая модификация его работы.
Я согласен с Джоном Скитом (это так просто :). Я попытался реализовать очень простой декоратор :
class NullComparators {
static <T> Comparator<T> atEnd(final Comparator<T> comparator) {
return new Comparator<T>() {
public int compare(T o1, T o2) {
if (o1 == null && o2 == null) {
return 0;
}
if (o1 == null) {
return 1;
}
if (o2 == null) {
return -1;
}
return comparator.compare(o1, o2);
}
};
}
static <T> Comparator<T> atBeginning(final Comparator<T> comparator) {
return Collections.reverseOrder(atEnd(comparator));
}
}
дан Comparator:
Comparator<String> wrapMe = new Comparator<String>() {
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
};
и некоторые тестовые данные:
List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null);
вы можете сортировать с нулями в конце:
Collections.sort(strings, NullComparators.atEnd(wrapMe));
[aaa, bbb, ccc, null, null, null]
или в начале:
Collections.sort(strings, NullComparators.atBeginning(wrapMe));
[null, null, null, ccc, bbb, aaa]
Вы всегда можете использовать NullComparator из общих коллекций. Он существует дольше, чем Google Collections.