Null-güvenli CompareTo () uygulamasını basitleştirmek nasıl?

compareTo()Bu gibi basit bir sınıf için yöntem uyguluyorum ( Collections.sort()Java platformu tarafından sunulan ve diğer güzellikleri kullanabilmek için):

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

// Imagine basic constructor and accessors here
// Irrelevant parts omitted
}

Bu nesneler için doğal sıralaması istiyorum : 1) ada göre ve 2) değere göre aynı ise; her iki karşılaştırma da büyük / küçük harfe duyarlı olmamalıdır. Her iki alan için null değerler mükemmel şekilde kabul edilebilir, bu nedenle compareTobu durumlarda kırılmamalıdır.

Akla gelen çözüm, aşağıdaki satırlar boyuncadır (Burada "bekçi hükümleri" kullanıyorum, diğerleri ise tek bir dönüş noktası tercih edebilir, ancak bu noktanın yanında):

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

Bu işi yapar, ancak bu koddan çok memnun değilim. Kuşkusuz çok karmaşık değil, oldukça ayrıntılı ve sıkıcı.

Soru, bunu nasıl daha az ayrıntılı hale getirirsiniz (işlevselliği korurken)? Yardımcı olurlarsa Java standart kitaplıklarına veya Apache Commons'a başvurmaktan çekinmeyin. Bunu (biraz) basitleştirmenin tek yolu kendi "NullSafeStringComparator'ımı uygulamak ve her iki alanı karşılaştırmak için uygulamak mı?

Düzenlemeler 1-3 : Eddie haklı; yukarıdaki "her iki ad da boş" durumu düzeltildi

Kabul edilen cevap hakkında

Bu soruyu 2009'da elbette Java 1.6'da sordum ve o zaman Eddie'nin saf JDK çözümü benim tercih ettiğim kabul edilen cevaptı. Bunu (2017) şimdiye kadar değiştirmek için hiç uğraşmadım.

Ayrıca, bir zamanlar tercih ettiğim 3. parti kütüphane çözümleri -a 2009 Apache Commons Koleksiyonları bir ve 2013 Guava biri- her zaman yayınladım.

Şimdi kabul edilen cevabı Lukasz Wiktor'un temiz Java 8 çözümünü yaptım . Bu, Java 8'de kesinlikle tercih edilmelidir ve bu günlerde Java 8 neredeyse tüm projeler için kullanılabilir olmalıdır.

Java 8'i kullanma :

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'ı kullanabilirsiniz :

result = ObjectUtils.compare(firstComparable, secondComparable)

Boş bir karşılaştırıcı uygulardım. Orada bir uygulama olabilir, ama uygulamak o kadar basittir ki, her zaman kendiminkini yuvarladım.

Not: Yukarıdaki karşılaştırıcınız, her iki ad da boşsa , değer alanlarını bile karşılaştırmaz. Bunun istediğini sanmıyorum.

Bunu aşağıdaki gibi bir şeyle uygularım:

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

EDIT: Kod örneğindeki yazım hataları düzeltildi. İlk önce test etmem için aldım!

EDIT: statik nullSafeStringComparator terfi etti.

Guava kullanarak güncellenmiş (2013) çözüm için bu cevabın alt kısmına bakın.

Sonunda bununla birlikte gittim. Null güvenli Dize karşılaştırması için zaten bir yardımcı programımız olduğu ortaya çıktı, bu yüzden en basit çözüm bundan faydalanmaktı. (Bu büyük bir kod tabanı; bu tür şeyleri kaçırmak kolay :)

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

Yardımcı bu şekilde tanımlanır (aşırı yüklenir, böylece isterseniz boş değerlerin önce mi yoksa son olarak mı geleceğini de tanımlayabilirsiniz):

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

Yani bu aslında Eddie'nin cevabı ile aynıdır (her ne kadar statik bir yardımcı yöntemi karşılaştırıcı olarak adlandırmasam da ) ve uzhin'in yanıtı .

Her neyse, genel olarak, Patrick'in çözümünü şiddetle tercih ederdim , çünkü mümkün olduğunca yerleşik kütüphaneleri kullanmak iyi bir uygulamadır. ( Josh Bloch'un dediği gibi kütüphaneleri bilin ve kullanın .) Ama bu durumda bu en temiz, en basit kodu vermezdi.

Edit (2009): Apache Commons Koleksiyonları sürümü

Aslında, Apache Commons tabanlı çözümü NullComparatordaha basit hale getirmenin bir yolu . Sınıfta sağlanan büyük / küçük harf duyarsızComparator ile birleştirin 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);
}

Şimdi bu oldukça zarif, sanırım. (Sadece küçük bir sorun var: NullComparatorMüşterekler jenerikleri desteklemediğinden kontrol edilmemiş bir görev var.)

Güncelleme (2013): Guava sürümü

Yaklaşık 5 yıl sonra, asıl sorumu nasıl çözeceğimi anlatacağım. Java kodlama, (tabii) Guava kullanıyor olacaktır . (Ve kesinlikle Apache Commons değil .)

Bu sabiti bir yere koyun, örneğin "StringUtils" sınıfında:

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

Sonra, içinde 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);
}    

Tabii ki, bu Apache Commons sürümüyle neredeyse aynıdır (her ikisi de JDava'nın CASE_INSENSITIVE_ORDER işlevini kullanır ), Guava'yanullsLast() özgü tek şey olmaktır. Bu sürüm tercih edilir çünkü Guava, Commons Koleksiyonlarına bağımlı olarak tercih edilir. ( Herkesin kabul ettiği gibi .)

Eğer merak ediyorsanız Ordering, bunun uygulandığını unutmayın Comparator. Özellikle daha karmaşık sıralama ihtiyaçları için oldukça kullanışlıdır, örneğin çeşitli Siparişleri kullanarak zincirlemenize izin verir compound(). Okuma Sipariş Açıklaması fazlası için!

Her zaman Apache ortaklarını kullanmanızı öneririm çünkü büyük olasılıkla kendi başınıza yazabileceğinizden daha iyi olacaktır. Ayrıca, yeniden icat etmek yerine 'gerçek' işler yapabilirsiniz.

İlgilendiğiniz sınıf Null Karşılaştırıcısı . Sıfırları yüksek veya düşük yapmanıza izin verir. Ayrıca, iki değer boş olmadığında kullanmak için kendi karşılaştırıcınızı da verirsiniz.

Sizin durumunuzda, karşılaştırmayı yapan statik bir üye değişkeniniz olabilir ve daha sonra compareToyönteminiz buna referans verir.

Gibi bir şey

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

}

Kendinizi döndürmeye karar verseniz bile, boş öğeleri içeren listeler sipariş ederken çok faydalı olduğu için bu sınıfı aklınızda bulundurun.

Sorunuzun doğrudan yanıtlanmayabileceğini biliyorum, çünkü boş değerlerin desteklenmesi gerektiğini söylediniz.

Ama ben sadece CompareTo nulls destekleme karşılaştırmak için karşılaştırmak istiyorum karşılaştırmak için resmi javadocs açıklanan sözleşme :

Null öğesinin herhangi bir sınıf örneği olmadığını ve e.equals (null) false döndürse bile e.compareTo (null) işlevinin bir NullPointerException özel durumu oluşturması gerektiğini unutmayın.

Bu yüzden ya NullPointerException'ı açıkça atarım ya da null argümanı serbest bırakıldığında ilk kez atılmasına izin veririm.

Yöntemi ayıklayabilirsiniz:

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

}

Sen değişmez olmasını sınıfını tasarım olabilir (. Etkili Java 2nd Ed bu konuda büyük bir bölümü vardır, Madde 15: mutability Minimize) ve hiçbir nulls mümkün olduğunu inşaatı üzerine emin olmak (ve kullanımı boş nesne modelini gerekiyorsa). Daha sonra tüm bu kontrolleri atlayabilir ve değerlerin güvenli olmadığını varsayabilirsiniz.

Benzer bir şey arıyordum ve bu biraz karmaşık görünüyordu, bu yüzden yaptım. Bence anlaşılması biraz daha kolay. Bir Karşılaştırıcı olarak veya bir astar olarak kullanabilirsiniz. Bu soru için CompareToIgnoreCase () ile değiştirirsiniz. Olduğu gibi, sıfırlar yüzer. Batmasını istiyorsanız 1, -1'i çevirebilirsiniz.

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

java 8'i nesne arasında boş bir karşılaştırma yapmak için kullanabiliriz. Diyelim ki 2 alanlı bir Boy sınıfı: String name ve Integer age ve önce isimleri karşılaştırmak istiyorum, sonra her ikisi de eşitse yaşlarım.

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

ve sonuç:

    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

Spring kullanan herkesin, bunu sizin için de yapan bir org.springframework.util.comparator.NullSafeComparator sınıfı vardır. Sadece bununla karşılaştırılabilir şekilde süsleyin

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

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

Verilerinde null değeri olmayacağını (her zaman dizeler için iyi bir fikir olduğunu) ve verilerin gerçekten büyük olduğunu bildiğiniz belirli bir durum için, değerleri gerçekten karşılaştırmadan önce yine de üç karşılaştırma yapıyorsunuz, bunun sizin durumunuz olduğundan emin olursanız , biraz optimize edebilirsiniz. Okunabilir kod olarak YMMV küçük optimizasyon koyar:

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


    }

}

çıktı

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 Karşılaştırıcısını kullanmanın basit yollarından biri, Bahar uygulamasını kullanmaktır, aşağıda atıfta bulunmak için basit örneklerden biri:

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

Başka bir Apache ObjectUtils örneği. Diğer nesne türlerini sıralayabilir.

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

Bu, ArrayList'imi sıralamak için kullandığım uygulama. null sınıfları sonuncuya kadar sıralanır.

benim durumum için, EntityPhone EntityAbstract genişletir ve benim konteyner List <EntityAbstract>.

null güvenli sıralama için "comparIfNull ()" yöntemi kullanılır. Diğer yöntemler, comparIfNull öğesinin nasıl kullanılabileceğini gösteren eksiksizlik içindir.

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

Basit bir Hack istiyorsanız:

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

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

listenin sonuna null koymak istiyorsanız yukarıdaki metod ile değiştirin.

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