Generischen comparator zu Sortieren Java Collections (List, Set)

Muss ich einige Allgemeine Komparator, die Sie akzeptieren würde-Instanzen der Liste oder als ein argument, und um die Richtung argument (ASC, DESC) und dann wieder die sortierte Sammlung. Ich kann nicht scheinen, um im internet finden diesem Beispiel, und bin in einem schrecklichen Eile. Ich weiß, dass ich nicht Fragen die Frage in der entsprechenden Weise, da ich keine code, um mit zu beginnen, bin aber in einem schrecklichen Eile. Die Sammlungen enthalten Objekte, die für die Einführung vergleichbarer und Termine.

Alle Beispiele, Umsetzungen sehr geschätzt.
Danke.

Ich kann dich verstehen das Sortieren einer Liste, aber nicht einen Satz. Java hat eine SortedSet aber nicht tatsächlich Sie zu Sortieren, Sie präsentieren Ihre Elemente in sortierter Reihenfolge, wenn Sie Durchlaufen. Was genau willst du diese "Komparator" zu tun?

InformationsquelleAutor Julia | 2011-08-02

5

Die Collections-Klasse hat eine reverseOrder Methode gibt ein Komparator für einen generischen Typ T das sollte erfüllen Ihre Anforderung für die DESC-Komparator. Wenn Sie die Weitergabe Ihrer Collection zu den Collections.sort() Methode, die es verwendet automatisch die ASC Sortieren.

Auch, "Sortieren" bedeutet nicht, eine Menge, wenn es um die "sets" die Pflege "unique" - Elemente in einer ungeordneten Art und Weise (ich meine, Sie können TreeSet für sortierte Sätze, aber das ist eine andere Geschichte). Eine einfache Lösung wäre eine List aus der Set und übergeben es an Collections.sort.

InformationsquelleAutor Sanjay T. Sharma
5

Mit GenericComparator.java werden Sie in der Lage zu Sortieren Sie folgende Datentypen Integer, String, Long, Double, Float, und Datum.

Für die Aufsteigende Reihenfolge
```
Collections.sort(persons, new GenericComparator("name", true));
```
Für eine Absteigende Reihenfolge
```
Collections.sort(persons, new GenericComparator("name", false));
```
Detaillierte Informationen finden Sie hier!

Toller Link. Danke.
Bitte lassen Sie mich wissen, den Grund für den down-vote. Also, ich kann eine Erklärung oder Verbesserung zu meiner Antwort, Danke.

InformationsquelleAutor jeevatkm

Dies könnte als ein basic-kick-off Beispiel für den Anfang mit Ihrer Anforderung :

//Create a list
String[] strArray = new String[] {"z", "a", "C"};
List list = Arrays.asList(strArray);

//Sort
Collections.sort(list);
//C, a, z

//Case-insensitive sort
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
//a, C, z

//Reverse-order sort
Collections.sort(list, Collections.reverseOrder());
//z, a, C

//Case-insensitive reverse-order sort
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(list);
//z, C, a

InformationsquelleAutor Sandeep Pathak

2

Müssen Sie rufen Sie Ihren Komparator mit den folgenden code.
```
Collection.sort(myList,new MyComparatorClass());
```
Dann müssen Sie erstellen Sie Ihre eigenen comparator-Klasse, das für die Sortierung auf Ihr Objekt bean entweder auf aufsteigend oder absteigend.In dieser Klasse vergleichen kann man das Grundstück, auf dem Sie ausführen möchten, zu Sortieren.Hier führe ich die Sortierung nach den Namen.
```
public class MyComparator  implements Comparator {

    public int compare(Object o1, Object o2) {
      return o1.getName().compareTo(o2.getName());
    }

}
```
InformationsquelleAutor Rupeshit

Hier ist mein Java-8 Allgemeine Komparator. Vergleichen Sie alle T auf die Funktion f(T) -> R, z.B. Person (T) Geburtsdatum (R). Da f sein kann, eine Methode, Verweis auf eine get-T, es ist einfach zu vergleichen, die auf jede Eigenschaft (Feld) von T. Es bietet für null-T-und null-R (Sie entscheiden, ob null-Werte gehen erste oder Letzte), als auch in aufsteigender/absteigender Reihenfolge. Seit es nutzt die natürlichen Bestellung von R, das letztere muss auch die Umsetzung Vergleichbar. Siehe Beispiel am Ende des Codes.

public class CompareUtil {

    public static enum Nulls {FIRST, LAST};
    public static enum Order {ASCENDING, DESCENDING};

    /** Return a Comparator of T on a function f(T) -> R */
    public static <T, R extends Comparable<? super R>> Comparator<T> comparatorOf(
            Function<T, R> function,
            Order order,
            Nulls nulls) {

        Comparator<R> rComparator = Comparator.naturalOrder();

        if (order == Order.DESCENDING) {
            rComparator = rComparator.reversed();
        }
        rComparator = (nulls == Nulls.FIRST)? 
                Comparator.nullsFirst(rComparator) :
                    Comparator.nullsLast(rComparator);

        Comparator<T> tComparator = 
                Comparator.comparing(
                        function, rComparator);

        tComparator = (nulls == Nulls.FIRST)? 
                Comparator.nullsFirst(tComparator) :
                    Comparator.nullsLast(tComparator);

        return tComparator;
    }

//Example: construct a comparator that compares Events on event-date
//in descending date order, putting any nulls at the end of the result set
Comparator<Event> c = comparatorOf(Event::getDate, Order.DESCENDING, Nulls.LAST);

InformationsquelleAutor Cornel Masson

Definieren Comparator - Schnittstelle
wie

public interface Comparator<T> {
  int compare(T o1, T o2);
  boolean equals(Object obj);
}

Klassen schreiben, die identifiziert und verglichen werden
zum Beispiel für Datum-Objekte

public class DateOrderComparator implements Comparator

Rang Komparator

public class RankCodeComparator implements Comparator

und so weiter...

InformationsquelleAutor GustyWind

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.