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

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 Java-8

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.

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

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

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.

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)

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

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?

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

}

}

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

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

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 .

Java 8 Lambda verkürzt die Sortierung.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Mit dem Bean Comparator können Sie nach jeder Eigenschaft in Ihrer benutzerdefinierten Klasse sortieren.

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.

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

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

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

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.

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

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.

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   

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

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.

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

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/

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.

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

Ich habe viele verschiedene im Internet verfügbare Lösungen ausprobiert, aber die für mich geeignete Lösung finden Sie unter dem folgenden Link.

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html