如何简化 null 安全的 compareTo（） 实现？

你可以把你的类设计成不可变的（Effective Java 2nd Ed. 有一个很好的部分，第 15 项：最小化可变性），并确保在构造时没有 null 是可能的（如果需要，请使用 null 对象模式）。然后，您可以跳过所有这些检查，并安全地假设这些值不为 null。

我将实现一个空安全比较器。那里可能有一个实现，但这实现起来非常简单，所以我总是推出自己的实现。

注意：如果两个名称都为空，则上面的比较器甚至不会比较值字段。我不认为这是你想要的。

我会用如下方式实现它：

// primarily by name, secondarily by value; null-safe; case-insensitive
public int compareTo(final Metadata other) {

    if (other == null) {
        throw new NullPointerException();
    }

    int result = nullSafeStringComparator(this.name, other.name);
    if (result != 0) {
        return result;
    }

    return nullSafeStringComparator(this.value, other.value);
}

public static int nullSafeStringComparator(final String one, final String two) {
    if (one == null ^ two == null) {
        return (one == null) ? -1 : 1;
    }

    if (one == null && two == null) {
        return 0;
    }

    return one.compareToIgnoreCase(two);
}

编辑：修复了代码示例中的拼写错误。这就是我不先测试它所得到的！

编辑：将 nullSafeStringComparator 提升为静态。

您可以提取方法：

public int cmp(String txt, String otherTxt)
{
    if ( txt == null )
        return otherTxt == null ? 0 : 1;
     
    if ( otherTxt == null )
          return 1;

    return txt.compareToIgnoreCase(otherTxt);
}

public int compareTo(Metadata other) {
   int result = cmp( name, other.name); 
   if ( result != 0 )  return result;
   return cmp( value, other.value); 

}

我总是建议使用Apache commons，因为它很可能比你自己编写的要好。此外，您可以进行“真正的”工作，而不是重新发明。

您感兴趣的类是 Null Comparator。它允许您使 null 变高或变低。您还可以为它提供自己的比较器，以便在两个值不为 null 时使用。

在你的例子中，你可以有一个静态成员变量来进行比较，然后你的方法只是引用它。compareTo

像

class Metadata implements Comparable<Metadata> {
private String name;
private String value;

static NullComparator nullAndCaseInsensitveComparator = new NullComparator(
        new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                // inputs can't be null
                return o1.compareToIgnoreCase(o2);
            }

        });

@Override
public int compareTo(Metadata other) {
    if (other == null) {
        return 1;
    }
    int res = nullAndCaseInsensitveComparator.compare(name, other.name);
    if (res != 0)
        return res;

    return nullAndCaseInsensitveComparator.compare(value, other.value);
}

}

即使您决定滚动自己的类，也要记住这个类，因为它在对包含 null 元素的列表进行排序时非常有用。

请参阅此答案的底部，了解使用番石榴的更新（2013）解决方案。

---

这就是我最终选择的。事实证明，我们已经有一个用于 null 安全字符串比较的实用方法，因此最简单的解决方案是使用它。（这是一个很大的代码库，很容易错过这种东西:)

public int compareTo(Metadata other) {
    int result = StringUtils.compare(this.getName(), other.getName(), true);
    if (result != 0) {
        return result;
    }
    return StringUtils.compare(this.getValue(), other.getValue(), true);
}

这是帮助程序的定义方式（它被重载，以便你还可以定义 null 是先出现还是最后出现，如果需要）：

public static int compare(String s1, String s2, boolean ignoreCase) { ... }

因此，这与 Eddie 的答案（尽管我不会将静态辅助方法称为比较器）和 uzhin 的答案基本相同。

无论如何，总的来说，我强烈赞成 Patrick 的解决方案，因为我认为尽可能使用已建立的库是一种很好的做法。（正如 Josh Bloch 所说，了解并使用这些库。但在这种情况下，这不会产生最干净、最简单的代码。

编辑 （2009）： Apache Commons Collections version

实际上，这里有一种方法可以使基于 Apache Commons NullComparator 的解决方案更简单。将其与类中提供的不区分大小写的比较器结合使用：String

public static final Comparator<String> NULL_SAFE_COMPARATOR 
    = new NullComparator(String.CASE_INSENSITIVE_ORDER);

@Override
public int compareTo(Metadata other) {
    int result = NULL_SAFE_COMPARATOR.compare(this.name, other.name);
    if (result != 0) {
        return result;
    }
    return NULL_SAFE_COMPARATOR.compare(this.value, other.value);
}

现在我认为这很优雅。（只剩下一个小问题：共享资源不支持泛型，所以有一个未经检查的分配。NullComparator

更新（2013）：番石榴版本

将近 5 年后，以下是我如何解决我最初的问题。如果用 Java 编码，我（当然）会使用 Guava。（当然不是 Apache Commons。

把这个常量放在某个地方，例如在“StringUtils”类中：

public static final Ordering<String> CASE_INSENSITIVE_NULL_SAFE_ORDER =
    Ordering.from(String.CASE_INSENSITIVE_ORDER).nullsLast(); // or nullsFirst()

然后，在：public class Metadata implements Comparable<Metadata>

@Override
public int compareTo(Metadata other) {
    int result = CASE_INSENSITIVE_NULL_SAFE_ORDER.compare(this.name, other.name);
    if (result != 0) {
        return result;
    }
    return CASE_INSENSITIVE_NULL_SAFE_ORDER.compare(this.value, other.value);
}    

当然，这与 Apache Commons 版本几乎相同（两者都使用 JDK的CASE_INSENSITIVE_ORDER），使用是唯一的番石榴特定的东西。这个版本更可取，仅仅是因为番石榴作为依赖项比共享资源收藏更可取。（大家都同意。nullsLast()

如果您想知道 Ordering，请注意它实现了 .它非常方便，特别是对于更复杂的排序需求，例如，允许您使用 .阅读订购说明以了解更多信息！Comparatorcompound()

您可以简单地使用 Apache Commons Lang：

result = ObjectUtils.compare(firstComparable, secondComparable)

我知道它可能无法直接回答您的问题，因为您说必须支持 null 值。

但我只想指出，在 compareTo 中支持 null 不符合 Compare 的官方 javadocs 中描述的 compareTo 合约：

请注意，null 不是任何类的实例，并且 e.compareTo（null） 即使 e.equals（null） 返回，也应该抛出 NullPointerException 假。

因此，我要么显式抛出 NullPointerException，要么在取消引用 null 参数时首次抛出它。

使用 Java 8：

private static Comparator<String> nullSafeStringComparator = Comparator
        .nullsFirst(String::compareToIgnoreCase); 

private static Comparator<Metadata> metadataComparator = Comparator
        .comparing(Metadata::getName, nullSafeStringComparator)
        .thenComparing(Metadata::getValue, nullSafeStringComparator);

public int compareTo(Metadata that) {
    return metadataComparator.compare(this, that);
}

我一直在寻找类似的东西，这似乎有点复杂，所以我这样做了。我认为这更容易理解。您可以将其用作比较器或单衬。对于这个问题，您将更改为 compareToIgnoreCase（）。按原样，空值浮动。如果你想让它们下沉，你可以翻转 1、-1。

StringUtil.NULL_SAFE_COMPARATOR.compare(getName(), o.getName());

.

public class StringUtil {
    public static final Comparator<String> NULL_SAFE_COMPARATOR = new Comparator<String>() {

        @Override
        public int compare(final String s1, final String s2) {
            if (s1 == s2) {
                //Nulls or exact equality
                return 0;
            } else if (s1 == null) {
                //s1 null and s2 not null, so s1 less
                return -1;
            } else if (s2 == null) {
                //s2 null and s1 not null, so s1 greater
                return 1;
            } else {
                return s1.compareTo(s2);
            }
        }
    }; 

    public static void main(String args[]) {
        final ArrayList<String> list = new ArrayList<String>(Arrays.asList(new String[]{"qad", "bad", "sad", null, "had"}));
        Collections.sort(list, NULL_SAFE_COMPARATOR);

        System.out.println(list);
    }
}

另一个 Apache ObjectUtils 示例。能够对其他类型的对象进行排序。

@Override
public int compare(Object o1, Object o2) {
    String s1 = ObjectUtils.toString(o1);
    String s2 = ObjectUtils.toString(o2);
    return s1.toLowerCase().compareTo(s2.toLowerCase());
}

如果有人使用 Spring，则有一个类 org.springframework.util.comparator.NullSafeComparator 也可以为您执行此操作。就这样装饰你自己的可比性

new NullSafeComparator<YourObject>(new YourComparable(), true)

https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/util/comparator/NullSafeComparator.html

这是我用来对 ArrayList 进行排序的实现。null 类按顺序排序到最后。

就我而言，EntityPhone 扩展了 EntityAbstract，我的容器是 List < EntityAbstract>。

“compareIfNull（）” 方法用于 null 安全排序。其他方法用于完整性，显示如何使用 compareIfNull。

@Nullable
private static Integer compareIfNull(EntityPhone ep1, EntityPhone ep2) {

    if (ep1 == null || ep2 == null) {
        if (ep1 == ep2) {
            return 0;
        }
        return ep1 == null ? -1 : 1;
    }
    return null;
}

private static final Comparator<EntityAbstract> AbsComparatorByName = = new Comparator<EntityAbstract>() {
    @Override
    public int compare(EntityAbstract ea1, EntityAbstract ea2) {

    //sort type Phone first.
    EntityPhone ep1 = getEntityPhone(ea1);
    EntityPhone ep2 = getEntityPhone(ea2);

    //null compare
    Integer x = compareIfNull(ep1, ep2);
    if (x != null) return x;

    String name1 = ep1.getName().toUpperCase();
    String name2 = ep2.getName().toUpperCase();

    return name1.compareTo(name2);
}
}


private static EntityPhone getEntityPhone(EntityAbstract ea) { 
    return (ea != null && ea.getClass() == EntityPhone.class) ?
            (EntityPhone) ea : null;
}

我们可以使用 Java 8 在对象之间做一个对 null 友好的比较。 假设我有一个带有 2 个字段的 Boy 类：字符串名称和整数年龄，如果两者相等，我想先比较名称，然后比较年龄。

static void test2() {
    List<Boy> list = new ArrayList<>();
    list.add(new Boy("Peter", null));
    list.add(new Boy("Tom", 24));
    list.add(new Boy("Peter", 20));
    list.add(new Boy("Peter", 23));
    list.add(new Boy("Peter", 18));
    list.add(new Boy(null, 19));
    list.add(new Boy(null, 12));
    list.add(new Boy(null, 24));
    list.add(new Boy("Peter", null));
    list.add(new Boy(null, 21));
    list.add(new Boy("John", 30));

    List<Boy> list2 = list.stream()
            .sorted(comparing(Boy::getName, 
                        nullsLast(naturalOrder()))
                   .thenComparing(Boy::getAge, 
                        nullsLast(naturalOrder())))
            .collect(toList());
    list2.stream().forEach(System.out::println);

}

private static class Boy {
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Boy(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "name: " + name + " age: " + age;
    }
}

结果：

    name: John age: 30
    name: Peter age: 18
    name: Peter age: 20
    name: Peter age: 23
    name: Peter age: null
    name: Peter age: null
    name: Tom age: 24
    name: null age: 12
    name: null age: 19
    name: null age: 21
    name: null age: 24

对于您知道数据不会有空值（对于字符串来说总是一个好主意）并且数据非常大的特定情况，在实际比较值之前，您仍然要进行三次比较，如果您确定这是您的情况，您可以稍微优化一下。YMMV 作为可读代码胜过次要优化：

        if(o1.name != null && o2.name != null){
            return o1.name.compareToIgnoreCase(o2.name);
        }
        // at least one is null
        return (o1.name == o2.name) ? 0 : (o1.name != null ? 1 : -1);

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Comparator;

public class TestClass {

    public static void main(String[] args) {

        Student s1 = new Student("1","Nikhil");
        Student s2 = new Student("1","*");
        Student s3 = new Student("1",null);
        Student s11 = new Student("2","Nikhil");
        Student s12 = new Student("2","*");
        Student s13 = new Student("2",null);
        List<Student> list = new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s11);
        list.add(s12);
        list.add(s13);

        list.sort(Comparator.comparing(Student::getName,Comparator.nullsLast(Comparator.naturalOrder())));

        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
            Student student = (Student) iterator.next();
            System.out.println(student);
        }


    }

}

输出是

Student [name=*, id=1]
Student [name=*, id=2]
Student [name=Nikhil, id=1]
Student [name=Nikhil, id=2]
Student [name=null, id=1]
Student [name=null, id=2]

使用 NullSafe Comparator 的简单方法之一是使用它的 Spring 实现，下面是参考的简单示例之一：

public int compare(Object o1, Object o2) {
        ValidationMessage m1 = (ValidationMessage) o1;
        ValidationMessage m2 = (ValidationMessage) o2;
        int c;
        if (m1.getTimestamp() == m2.getTimestamp()) {
            c = NullSafeComparator.NULLS_HIGH.compare(m1.getProperty(), m2.getProperty());
            if (c == 0) {
                c = m1.getSeverity().compareTo(m2.getSeverity());
                if (c == 0) {
                    c = m1.getMessage().compareTo(m2.getMessage());
                }
            }
        }
        else {
            c = (m1.getTimestamp() > m2.getTimestamp()) ? -1 : 1;
        }
        return c;
    }

如果你想要一个简单的 Hack：

arrlist.sort((o1, o2) -> {
    if (o1.getName() == null) o1.setName("");
    if (o2.getName() == null) o2.setName("");

    return o1.getName().compareTo(o2.getName());
})

如果你想把空值放在列表的末尾，只需在 metod 上面更改它

return o2.getName().compareTo(o1.getName());

可以处理 null 方面并在自定义方法实现中使用的泛型实用程序类可能如下所示：compareTo

/**
 * Generic utility class for null-safe comparison.
 */
public class Comparing
{
    /**
     * Compares two objects for order. Returns a negative integer, zero, or a
     * positive integer if the first object is less than, equal to, or greater
     * than the second object. Any of the objects can be null. A null value is
     * considered to be less than a non-null value.
     * 
     * @param <T>
     * @param a the first object.
     * @param b the second object.
     * @return an integer value.
     */
    public static <T extends Comparable<T>> int compareTo( T a, T b )
    {
        if ( a == b )
        {
            return 0;
        }

        return a != null ? b != null ? a.compareTo( b ) : 1 : -1;
    }
}