Sortieren ArrayList mit benutzerdefinierten Objekten durch die Eigenschaft

Seit Date implements Comparable, es hat einen compareTo Methode wie String tut.

So Ihre eigenen Comparator könnte wie folgt Aussehen:

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

Den compare() Methode muss wieder ein int, also konnten Sie nicht direkt zurückgeben boolean wie Sie planen, sowieso.

Ihre Sortier-code würde nur darüber zu sein, wie du geschrieben hast:

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

Einen etwas kürzeren Weg zu schreiben, alle diese, wenn Sie nicht brauchen, um verwenden Sie Ihre Komparator, ist, es zu schreiben, als ein inline-anonyme Klasse:

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

Seit java-8

Können Sie nun schreiben Sie das Letzte Beispiel in einer kürzeren form mit lambda-Ausdruck für die Comparator:

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

Sowie List hat eine sort(Comparator) Methode, so können Sie diese kürzen noch weiter:

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

Dies ist so eine gängige Redewendung, dass es integrierte Methode zu generieren Comparator für eine Klasse mit einer Comparable Schlüssel:

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

Alle diese sind äquivalente Formen.

InformationsquelleAutor Michael Myers

Zum Sortieren eines ArrayList könnten Sie den folgenden code-snippet:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

InformationsquelleAutor

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)

InformationsquelleAutor Sorter

Da Technologien erscheinen jeden Tag, die Antwort wird in der Zeit zu ändern. Ich warf einen Blick auf LambdaJ und scheint sehr interessant.

Können Sie versuchen, die Lösung dieser Aufgaben mit LambdaJ. Sie können es hier finden: http://code.google.com/p/lambdaj/

Hier haben Sie ein Beispiel:

Art Iterative

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

Art mit lambda

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

Natürlich, dass diese Art von Schönheit, die Auswirkungen in der Leistung (Durchschnitt 2 mal), aber finden Sie einen besser lesbaren code?

InformationsquelleAutor Federico Piazza

Besten einfach Weg mit JAVA 8 ist für Englisch Alphabetische Sortierung

Klasse Umsetzung

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

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

Art

  Collections.sort(Your List);

Wenn Sie möchten, sortiert nach alphabet, enthält nicht-englische Zeichen, die Sie verwenden können, Locale... folgenden code verwenden türkischen Charakter Sortieren...

Klasse Umsetzung

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

Art

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

InformationsquelleAutor Beyaz

Vom Java 8 und weiter haben wir nicht verwenden Collections.sort() direkt. List - Schnittstelle hat eine voreingestellte sort() Methode:

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

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

InformationsquelleAutor Vishnu Vasudevan

Ja, das ist möglich, zum Beispiel in diese Antwort ich Sortieren, indem Sie die Eigenschaft v von der Klasse IndexValue

    //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 bemerken, hier ich bin die Schaffung einer anonyme innere Klasse ( das ist das Java für Verschlüsse ) und übergeben Sie direkt an den sort Methode der Klasse Arrays

Wird das Objekt eventuell auch umsetzen Comparable ( das ist, was die String-und die meisten der core-Bibliotheken, die in Java), aber, dass die Definition der "natürlichen " Sortierreihenfolge" der Klasse selbst, und nicht lassen stecken Sie das neue.

InformationsquelleAutor OscarRyz

Java 8 Lambda verkürzt die Art.

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

InformationsquelleAutor javasenior

Fand ich die meisten, wenn nicht alle diese Antworten basieren auf der zugrunde liegenden Klasse (Object) zu implementieren, die vergleichbare oder einen Helfer vergleichbare Schnittstelle.

Nicht mit meiner Lösung! Den folgenden code können Sie vergleichen Objektfeld durch das wissen um die string name. Sie könnten leicht ändern Sie es nicht, den Namen zu verwenden, aber dann müssen Sie es bekannt machen oder den Bau eines der Objekte, die Sie vergleichen möchten gegen.

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

InformationsquelleAutor Kevin Parker

Können Sie einen Blick in diese Präsentation halten Sie auf dem Java Forum in Stuttgart, Deutschland im Jahr 2016.

Nur wenige Folien verwenden der deutschen Sprache, die 99% des Inhalts ist "englischen" Java-source-code; wie

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

wo OurCustomComparator ist mit Standard-Methoden (und andere interessante Ideen). Wie gezeigt, führt zu sehr übersichtlichen code zu Holen einige getter-Methode für die Sortierung und super einfache Verkettung (oder Umkehrung) der Sortierkriterien.

Wenn Sie in java8, finden Sie eine Menge von material gibt, um Ihnen den Einstieg.

InformationsquelleAutor GhostCat

Mit dieser Bibliothek hier Sie können die Sortierung der Liste der benutzerdefinierten Objekte auf mehreren Säulen. Die Bibliothek nutzt die version 8.0 bietet. Probe ist ebenfalls verfügbar. Hier ist ein Beispiel, das 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);

InformationsquelleAutor Shriram M.

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 Sie die Liste der Objekte, die hat eine Eigenschaft namens startDate rufen Sie dies nicht über und über. Sie können auch Kette Sie startDate.time.

Dies erfordert, dass die Objekt Comparable was bedeutet, Sie müssen eine compareTo, equals, und hashCode Umsetzung.

Ja, es könnte schneller sein... Aber jetzt müssen Sie nicht haben, um eine neue Komparator für jeden Typ sort. Wenn Sie speichern können auf dev und Zeit geben, auf die Laufzeit, könnte man mit diesem einen.

InformationsquelleAutor DDus

Ihrer benutzerdefinierten Klasse implementieren kann, die "Vergleichbar" - Schnittstelle, die erfordert eine Implementierung der CompareTo-Methode. In der CompareTo-Methode können Sie dann definieren, was es bedeutet, dass ein Objekt weniger als oder mehr als das andere Objekt. Also in deinem Beispiel, kann es wie folgt 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 bedeutet, dass diese kleiner ist als das Objekt, das im Vergleich zu. Eine positive Zahl zeigt an, dass diese ist größer als die, im Vergleich zum Objekt und eine Null bedeutet, dass die Objekte gleich sind.

Dann können Sie die Sammlungen.sort(myList) zu Sortieren Sie Ihre Liste ohne Futter in einem Komparator. Diese Methode hat auch den Vorteil, dass Dinge automatisch sortiert, wenn Sie eine geordnete Sammlung von Daten Strukturen wie TreeSet oder einer TreeMap.

Können Sie Lesen Sie diesen Artikel, wenn Sie möchten, um mehr über die Vergleichbare Schnittstelle (Offenlegung: ich bin der Autor 😉 )
https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

InformationsquelleAutor A.Ebrahim