nullセーフのcompareTo（）実装を単純化する方法は？
次のような単純なクラスにcompareTo()メソッドを実装しています（Collections.sort()およびJavaプラットフォームで提供されるその他の利点を使用できるようにするため）：
public class Metadata implements Comparable<Metadata> {
private String name;
private String value;
// Imagine basic constructor and accessors here
// Irrelevant parts omitted
}
これらのオブジェクトの自然順序付けは、1）名前で並べ替え、2）名前が同じ場合は値で並べ替えます。両方の比較で大文字と小文字を区別しないでください。両方のフィールドでnull値は完全に許容されるため、これらの場合compareToは壊れてはいけません。
頭に浮かぶ解決策は、次のようなものです（ここでは「ガード句」を使用していますが、他の人は単一のリターンポイントを好むかもしれませんが、それはポイントの横にあります）。
// primarily by name, secondarily by value; null-safe; case-insensitive
public int compareTo(Metadata other) {
if (this.name == null && other.name != null){
return -1;
}
else if (this.name != null && other.name == null){
return 1;
}
else if (this.name != null && other.name != null) {
int result = this.name.compareToIgnoreCase(other.name);
if (result != 0){
return result;
}
}
if (this.value == null) {
return other.value == null ? 0 : -1;
}
if (other.value == null){
return 1;
}
return this.value.compareToIgnoreCase(other.value);
}
これは仕事をしますが、私はこのコードに完全に満足していません。確かに非常に複雑ではありませんが、非常に冗長で退屈です。
問題は、これをどのように冗長性の低いものにしますか（機能を保持しながら）？役立つ場合は、Java標準ライブラリまたはApache Commonsを参照してください。これを（少し）簡単にする唯一のオプションは、独自の "NullSafeStringComparator"を実装し、両方のフィールドの比較に適用することですか？
Edits 1-3：Eddieの権利;上記の「両方の名前がヌル」の場合を修正
受け入れられた回答について
私はこの質問を2009年にJava 1.6で、そして当時Eddieによる純粋なJDKソリューション私の好みの受け入れられた答えでした。私はそれを今まで（2017年）まで変えることはできませんでした。
サードパーティのライブラリソリューション — 2009年のApache Commons Collections 1つと2013年のGuava 1つ（どちらも私から投稿されたもの）もあります。
クリーンLukasz WiktorによるJava 8ソリューションを受け入れられた答えにしました。 Java 8で、最近ではJava 8がほぼすべてのプロジェクトで利用可能になっている場合、これは間違いなく優先されるはずです。
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);
}
Apache Commons Lang を使用するだけです：
result = ObjectUtils.compare(firstComparable, secondComparable)
Nullセーフコンパレーターを実装します。実装があるかもしれませんが、これは実装するのが非常に簡単なので、私は常に自分自身をロールバックしました。
注：bothの名前が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を静的に昇格しました。
Guavaを使用した更新済み（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's answer （静的ヘルパーメソッドacomparator）と zhinの呼び出しはしませんが）と同じです も。
とにかく、一般的には、確立されたライブラリを可能な限り使用することをお勧めすると思いますので、私は Patrickのソリューション を強く推奨します。 （Josh Blochが言うように、ライブラリを知って使用してください。）しかし、この場合、最もクリーンでシンプルなコードは生成されませんでした。
編集（2009）：Apache Commons Collectionsバージョン
実際には、Apache Commons NullComparator に基づいたソリューションをより簡単にする方法があります。それをComparatorクラスで提供される 大文字と小文字を区別しない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);
}
これはかなりエレガントです。 （小さな問題が1つだけ残っています。CommonsNullComparatorはジェネリックをサポートしないため、未チェックの割り当てがあります。）
更新（2013）：グアババージョン
ほぼ5年後、元の質問にどのように取り組むかを示します。 Javaでコーディングする場合、（もちろん） Guava を使用します。 （そして間違いなくnotApache 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()の使用が唯一のGuava固有のものです。 Commons CollectionsよりもGuavaが依存関係として望ましいため、このバージョンが望ましいです。 （ 全員が同意する として。）
Ordering について疑問に思っている場合は、Comparatorを実装していることに注意してください。特に、より複雑なソートのニーズに非常に便利です。たとえば、compound()を使用して複数の順序付けを連鎖できます。 注文の説明 を読んでください！
Apache commonsを使用することをお勧めします。Apachecommonsは、独自に作成できるものよりも優れている可能性が高いためです。さらに、再発明するのではなく、「実際の」作業を行うことができます。
興味のあるクラスは Null Comparator です。 nullを高くしたり低くしたりできます。また、2つの値が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要素を含むリストを順序付けるときに非常に役立つため、このクラスを覚えておいてください。
ヌル値をサポートする必要があると言ったので、あなたの質問に直接答えないかもしれないことを知っています。
しかし、compareToでnullをサポートすることは、公式の Comparableのjavadocs で説明されているcompareToコントラクトと一致しないことに注意してください。
Nullはどのクラスのインスタンスでもないことに注意してください。e.equals（null）はfalseを返しますが、e.compareTo（null）はNullPointerExceptionをスローする必要があります。
そのため、NullPointerExceptionを明示的にスローするか、null引数が逆参照されているときに初めてスローされるようにします。
メソッドを抽出できます：
public int cmp(String txt, String otherTxt)
{
if ( txt == null )
return otjerTxt == 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);
}
クラスを不変に設計し（効果的なJava 2nd Ed。にこれに関する素晴らしいセクション、項目15：可変性を最小限に抑える）、構築時にnullが不可能であることを確認します（そして nullオブジェクトパターン 必要に応じて）。その後、これらのチェックをすべてスキップして、値がnullでないと安全に想定できます。
Java 8を使用して、オブジェクト間のNULLフレンドリーな比較を行うことができます。文字列名と整数年齢の2つのフィールドを持つボーイクラスを持っていると仮定し、最初に名前を比較し、次に両方が等しい場合は年齢を比較したいと思います。
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
私は似たようなものを探していましたが、これは少し複雑に思えたので、これを行いました。少しわかりやすいと思います。コンパレーターまたは1つのライナーとして使用できます。この質問では、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);
}
}
Springを使用している場合は、org.springframework.util.comparator.NullSafeComparatorクラスもあります。このようにそれに匹敵するあなた自身を飾るだけ
new NullSafeComparator<YourObject>(new YourComparable(), true)
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を使用 の簡単な方法の1つは、Spring実装を使用することです。以下は、参照する簡単な例の1つです。
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;
}
データにnullが含まれず（常に文字列の場合は良い考えです）、データが非常に大きいことがわかっている特定のケースでは、実際に値を比較する前に3回の比較を実行していますこれが確実にわかっている場合あなたの場合、少しビットを最適化できます。読み取り可能なコードとしての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);
これは、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;
}
別の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());
}