Sortieren Sie die ArrayList der benutzerdefinierten Objekte nach der Eigenschaft

1145

Ich habe über das Sortieren von ArrayLists mit einem Komparator gelesen, aber in allen Beispielen wurden Leute verwendet, compareTodie nach einigen Untersuchungen eine Methode für Strings sind.

Ich wollte eine ArrayList von benutzerdefinierten Objekten nach einer ihrer Eigenschaften sortieren: einem Date-Objekt ( getStartDay()). Normalerweise vergleiche ich sie mit, item1.getStartDate().before(item2.getStartDate())also habe ich mich gefragt, ob ich so etwas schreiben könnte:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}
Samuel
quelle
3
Siehe auch
BalusC
2
Die Antwort von @Yishai in diesem Beitrag zeigt die elegante Verwendung von Enum für die benutzerdefinierte Sortierung und Gruppensortierung (mehrere Argumente) unter Verwendung der Komparatorverkettung.
Gunalmel

Antworten:

1538

Da Dateimplementiert Comparable, hat es eine compareToMethode wie Stringtut.

Ihr Brauch Comparatorkönnte also so aussehen:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

Die compare()Methode muss ein zurückgeben int, sodass Sie ein direktes Ergebnis nicht direkt zurückgeben booleankönnen.

Ihr Sortiercode würde ungefähr so ​​sein, wie Sie geschrieben haben:

Collections.sort(Database.arrayList, new CustomComparator());

Eine etwas kürzere Möglichkeit, dies alles zu schreiben, wenn Sie Ihren Komparator nicht wiederverwenden müssen, besteht darin, ihn als anonyme Inline-Klasse zu schreiben:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Schon seit

Sie können das letzte Beispiel jetzt in kürzerer Form schreiben, indem Sie einen Lambda-Ausdruck für Folgendes verwendenComparator :

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Und Listhat eine sort(Comparator)Methode, so dass Sie diese noch weiter verkürzen können:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Dies ist eine so verbreitete Redewendung, dass es eine integrierte Methode gibt , um eine Comparatorfür eine Klasse mit einem ComparableSchlüssel zu generieren :

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

All dies sind äquivalente Formen.

Michael Myers
quelle
33
+1 für die Erwähnung, dass es zurückkehren sollte intund dass Sie es besser dafür verwenden sollten Date#compareTo(). Warum dies nicht über der anderen Antwort steht, ist mir ein Rätsel. Dieser Link kann auch nützlich sein: Tutorial zur Objektbestellung bei Sun.com .
BalusC
5
Ich denke, die beste Antwort sollte auch die richtige Vorgehensweise in Java 8 enthalten. Collections.sort (list, Comparator.comparing (MyObject :: getStartDate)); Das liest sich besser und ist weniger fehleranfällig. Es ist sehr einfach, return o1.getStartDate () zu schreiben. CompareTo (o1.getStartDate ());
Kuba
2
Die Vergleichsklasse sollte statisch sein :)
Jarmez De La Rocha
4
@ Kuba noch besser, verwenden List.sort().
Shmosel
3
Diese Lösung funktioniert nicht mit Android API <24. Kennt ihr eine Lösung dafür?
Jim Clermonts
194

Klassen mit einer natürlichen Sortierreihenfolge (z. B. eine Klassennummer) sollten die Schnittstelle Comparable implementieren, während Klassen ohne natürliche Sortierreihenfolge (z. B. ein Klassenstuhl) einen Komparator (oder einen anonymen Komparator) erhalten sollten Klasse).

Zwei Beispiele:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Verwendungszweck:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});
Björn
quelle
Ich habe das versucht - aber wenn ich außerhalb einer anderen Klasse auf die Vergleichsklasse ChairWeightComparator zugreifen möchte, erhalte ich keinen Zugriff auf diese Klasse (natürlich nicht, da sie nicht öffentlich ist). Muss ich eine neue öffentliche ChairWeightComparator-Klasse in einer separaten Datei erstellen? - Bin ich wirklich der erste, der dies nach 3 Jahren versucht hat oder habe ich etw vermisst?
user387184
@ user387184 - machen Sie es einfach öffentlich und legen Sie es in einer eigenen Datei ab (vorzugsweise auch in einem eigenen Paket), und Sie können es überall in Ihrem Projekt verwenden. Sie müssen keine zusätzliche Klasse erstellen!
Björn
Sie meinen, erstellen Sie eine neue Datei - keine Klasse und geben Sie den Code ein: "class ChairWeightComparator implementiert Comparator <Chair> {...."?
user387184
@ user387184, genau - aber mit dem Schlüsselwort publicvor class.
Björn
157

Zum Sortieren eines können ArrayListSie das folgende Code-Snippet verwenden:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});
schwarzer Panther
quelle
1
Jeder mit Lambda stackoverflow.com/questions/2784514/...
Sorter
Das sortiert aber gibt doppelten Wert für jedes Element
Sam
44

Ja, du kannst. Beim Vergleichen von Elementen gibt es zwei Optionen: die Schnittstelle " Vergleichbar " und die Schnittstelle " Vergleicher ".

Beide Schnittstellen ermöglichen ein unterschiedliches Verhalten. Mit Comparable können Sie das Objekt so verhalten lassen, wie Sie es gerade beschrieben haben (Strings implementiert Comparable). Mit dem zweiten Komparator können Sie das tun, worum Sie bitten. Du würdest es so machen:

Collections.sort(myArrayList, new MyComparator());

Dadurch verwendet die Collections.sort-Methode Ihren Komparator für den Sortiermechanismus. Wenn die Objekte in der ArrayList vergleichbar sind, können Sie stattdessen Folgendes tun:

Collections.sort(myArrayList);

Die Collections- Klasse enthält eine Reihe dieser nützlichen, allgemeinen Tools.

Aperkins
quelle
42

JAVA 8 Lambda-Ausdruck

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

ODER

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
Sorter
quelle
3
OderCollections.sort(studList, Comparator.comparing(Student::getFirstName));
Holger
5
.. oderstudList.sort(Comparator.comparing(Student::getFirstName));
Alexis C.
Die Sortierreihenfolge wird in Ihrem Fall immer aufsteigend sein. In meinem Beispiel habe ich mich auch um die Sortierreihenfolge gekümmert. Vielen Dank, meine Herren.
Sortierer
33

Mit Java 8 können Sie eine Methodenreferenz für Ihren Komparator verwenden:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));
Assylien
quelle
@ user387184 android unterstützt Java 8 leider nicht, obwohl es möglicherweise eine Problemumgehung gibt (ich habe es nicht getestet).
Assylias
14

Da Technologien jeden Tag erscheinen, wird sich die Antwort im Laufe der Zeit ändern. Ich habe mir LambdaJ angesehen und scheint sehr interessant zu sein.

Sie können versuchen, diese Aufgaben mit LambdaJ zu lösen . Sie finden es hier: http://code.google.com/p/lambdaj/

Hier haben Sie ein Beispiel:

Iterativ sortieren

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Mit Lambda sortieren

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Natürlich wirkt sich diese Art von Schönheit auf die Leistung aus (durchschnittlich zweimal), aber können Sie einen besser lesbaren Code finden?

Federico Piazza
quelle
Das sortiert, gibt aber einen doppelten Wert für jedes Element, wie man es vermeidet
Sam
@ Sam, es sollte nicht ... es funktioniert wie erwartet. Es sei denn, Sie verwenden eine neue Version mit einem Fehler. Ich empfehle Ihnen, diese im Forum zu veröffentlichen. Wie auch immer, diese Antwort wurde vor Java 8 veröffentlicht. Wenn Sie sie verwenden, ist sie viel besser als Lambdaj
Federico Piazza
Ich musste sogar Elemente in einer foreach-Schleife entfernen, sonst erhält ich das Doppelte jedes Inhalts.
Sam
13
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}
CharlesW
quelle
7
Willkommen beim Stackoverflow. Diese Frage wurde vor einiger Zeit beantwortet. Vergewissern Sie sich vor der Wiederbelebung alter Threads, dass Ihre Antwort dem Thread etwas Bedeutendes hinzufügt.
Leigh
1
Bitte fügen Sie Ihrer Antwort eine Erklärung hinzu.
Arashsoft
Einfach kompilieren und ausführen. Der Code ist der Kommentar und die Erklärung.
CharlesW
9

Der beste einfache Weg mit JAVA 8 ist die englische alphabetische Sortierung

Klassenimplementierung

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Sortieren

  Collections.sort(Your List);

Wenn Sie nach einem Alphabet sortieren möchten, das nicht englische Zeichen enthält, können Sie das Gebietsschema verwenden ... Unterhalb des Codes verwenden Sie die türkische Zeichensortierung ...

Klassenimplementierung

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Sortieren

Collections.sort(your array list,new NewspaperClass());
Beyaz
quelle
9

Funktions- und Methodenreferenz

Die Collections.sortMethode kann eine Listmit einem von ComparatorIhnen übergebenen sortieren . Dies Comparatorkann mit der Comparator.comparingMethode implementiert werden , bei der Sie bei Bedarf eine Methodenreferenz übergeben können Function. Glücklicherweise ist der eigentliche Code viel einfacher und kürzer als diese Beschreibung.

Für Java 8:

Collections.sort(list, comparing(ClassName::getName));

oder

Collections.sort(list, comparing(ClassName::getName).reversed());

Ein anderer Weg ist

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
Arun
quelle
1
Anruf erfordert API-Level 24
akshay bhange
6

Ab Java 8und zu müssen wir nicht mehr Collections.sort()direkt verwenden. ListSchnittstelle hat eine Standardmethode sort():

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

Siehe http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html .

Vishnu Vasudevan
quelle
6

Java 8 Lambda verkürzt die Sortierung.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
javasenior
quelle
2
Collections.sort(stdList, Comparator.comparing(SomeClass::getName));
bcsb1001
5

Ja, das ist zum Beispiel in dieser Antwort möglich, die ich nach der Eigenschaft vder Klasse sortiereIndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Wenn Sie hier bemerken, erstelle ich eine anonyme innere Klasse (Java für Closures) und übergebe sie direkt an die sortMethode der KlasseArrays

Ihr Objekt kann auch implementiert werden Comparable(das ist es, was String und die meisten Kernbibliotheken in Java tun), aber das würde die "natürliche Sortierreihenfolge" der Klasse selbst definieren und Sie können keine neuen einfügen.

OscarRyz
quelle
1
... aber mit denen Sie einfach überschreiben können Comparator:)
BalusC
5

Ich fand, dass die meisten, wenn nicht alle dieser Antworten auf der zugrunde liegenden Klasse (Objekt) beruhen, um eine vergleichbare oder eine helfervergleichbare Schnittstelle zu implementieren.

Nicht mit meiner Lösung! Mit dem folgenden Code können Sie das Feld des Objekts vergleichen, indem Sie dessen Zeichenfolgennamen kennen. Sie können es leicht ändern, um den Namen nicht zu verwenden, aber dann müssen Sie es verfügbar machen oder eines der Objekte erstellen, mit denen Sie vergleichen möchten.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}
Kevin Parker
quelle
5

Sie können versuchen, Guave zu bestellen :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);
Vitalii Fedorenko
quelle
5

Sie können mit Java 8 sortieren

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
Sucher
quelle
3

Diese Codefragmente könnten nützlich sein. Wenn Sie in meinem Fall ein Objekt sortieren möchten, möchte ich nach VolumeName sortieren:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Das funktioniert. Ich benutze es in meinem jsp.

Laura Liparulo
quelle
3

Mit dieser Bibliothek können Sie hier die Liste der benutzerdefinierten Objekte nach mehreren Spalten sortieren. Die Bibliothek verwendet Funktionen der Version 8.0. Dort gibt es auch ein Muster. Hier ist ein Beispiel zu tun

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);
Shriram M.
quelle
3

Sie können sich diese Präsentation auf dem Java-Forum in Stuttgart 2016 ansehen .

Nur wenige Folien verwenden die deutsche Sprache. 99% des Inhalts besteht aus "englischbasiertem" Java-Quellcode. mögen

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

wo OurCustomComparator werden Standardmethoden (und andere interessante Ideen) verwendet? Wie gezeigt, führt dies zu einem sehr präzisen Code, um eine Getter-Methode zum Sortieren auszuwählen. und supereinfaches Verketten (oder Umkehren) von Sortierkriterien.

Wenn Sie sich für Java8 interessieren, finden Sie dort viel Material, um loszulegen.

GhostCat
quelle
3

Neu seit 1.8 ist eine List.sort () -Methode anstelle der Collection.sort (), sodass Sie mylistcontainer.sort () direkt aufrufen.

Hier ist ein Code-Snippet, das die Funktion List.sort () demonstriert:

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

Die Obstklasse ist:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   
Norbert
quelle
2

Ihre customComparator-Klasse muss java.util.Comparator implementieren, um verwendet zu werden. es muss auch compare () AND equals () überschreiben

compare () muss die Frage beantworten: Ist Objekt 1 kleiner, gleich oder größer als Objekt 2?

Vollständige Dokumente: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Vinny
quelle
1

Ich bevorzuge diesen Prozess:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Wenn Ihre Objektliste eine Eigenschaft mit dem Namen hat startDate, rufen Sie diese immer wieder auf. Sie können sie sogar verketten startDate.time.

Dies erfordert , dass Ihr Objekt zu sein , Comparabledas heißt , Sie brauchen einen compareTo, equalsund hashCodeImplementierung.

Ja, es könnte schneller sein ... Aber jetzt müssen Sie nicht für jede Art von Sortierung einen neuen Komparator erstellen. Wenn Sie Entwicklungszeit sparen und die Laufzeit aufgeben können, können Sie sich für diese entscheiden.

DDus
quelle
3
1, diese Antwort wurde 2 Stunden zuvor mit Arbeitscode ebenfalls gegeben. Es ist nicht erforderlich, dieselbe Lösung erneut zu veröffentlichen und das Forum zu überladen, zumal BeanComparator keine Standardklasse ist. Daher ist es keine echte Lösung, wenn das Poster nicht weiß, wovon Sie sprechen. Wenn Ihnen der ursprüngliche Vorschlag gefällt, können Sie ihn positiv bewerten und einen Kommentar hinzufügen, wenn Sie dies wünschen.
Camickr
0

Mit Java 8 kann die Verwendung Comparatorin einer Zeile mit definiert werdenComparator.comparing()

Verwenden Sie eine der folgenden Möglichkeiten:

Option 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Option 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));
Sahil Chhabra
quelle
1
Scheint ein Duplikat dieser Antwort von 3 Jahren zuvor zu sein.
Basil Bourque
1
Nicht genau, nur Option 2 hier ähnelt Option 1 in der genannten Antwort. Ich bin der Meinung, dass zwei unterschiedliche Antworten zumindest einige Ähnlichkeiten aufweisen können, wenn sie auf dieselbe Frage beantwortet werden.
Sahil Chhabra
0

Ihre benutzerdefinierte Klasse kann die Schnittstelle "Comparable" implementieren, für die die CompareTo-Methode implementiert werden muss. In der CompareTo-Methode können Sie dann definieren, was es bedeutet, dass ein Objekt kleiner oder größer als das andere Objekt ist. In Ihrem Beispiel kann es also ungefähr so ​​aussehen:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

Eine negative Zahl zeigt an, dass dies kleiner ist als das Objekt, mit dem verglichen wird. Eine positive Zahl zeigt dies an größer als das im Vergleich zum Objekt ist, und eine Null bedeutet, dass die Objekte gleich sind.

Sie können dann die collection.sort (myList) verwenden, um Ihre Liste zu sortieren, ohne einen Komparator eingeben zu müssen. Diese Methode hat auch den Vorteil, dass Dinge automatisch sortiert werden, wenn Sie sortierte Sammlungsdatenstrukturen wie ein TreeSet oder eine TreeMap verwenden.

Sie können diesen Artikel lesen, wenn Sie mehr über die vergleichbare Oberfläche lesen möchten (Offenlegung: Ich bin der Autor;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Nullbohnen
quelle
0

Sie können Springs PropertyComparator auch verwenden, wenn Sie nur einen String-Eigenschaftspfad zu der (verschachtelten) Eigenschaft haben, die Sie sortieren möchten:

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

Der Nachteil ist, dass dieser Komparator Eigenschaften, die nicht vorhanden oder nicht zugänglich sind, stillschweigend ignoriert und dies als Nullwert für den Vergleich behandelt. Dies bedeutet, dass Sie einen solchen Komparator sorgfältig testen oder die Existenz des Eigenschaftspfads irgendwie überprüfen sollten.

xtermi2
quelle
0

Mit der Java-8-Stream-API können Sie eine sortieren ArrayListnach:

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());
pero_hero
quelle