Wie verwende ich Comparator, um eine benutzerdefinierte Sortierreihenfolge zu definieren?

Lesezeit: 5 Minuten

Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
achtar

Ich möchte eine Sortierdemo für die Autoliste entwickeln. Ich verwende die Datentabelle, um die Fahrzeugliste anzuzeigen. Jetzt möchte ich eigentlich die Liste nach Autofarbe sortieren. Hier wird nicht alphabetisch sortiert. Ich möchte meine benutzerdefinierte Sortierreihenfolge verwenden, z. B. kommt zuerst das rote Auto, dann das blaue usw.

Dafür versuche ich Java zu verwenden Comparator und Comparable aber es erlaubt nur in alphabetischer Reihenfolge zu sortieren.

Kann mir also jemand den Weg weisen, die zu verwendende Technik zu implementieren, damit das Sortieren schneller wird?

class Car implements Comparable<Car>
{
    private String name;
    private String color;

    public Car(String name, String color){
        this.name = name;
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(Car c) {
        return name.compareTo(c.name);
    }

    static class ColorComparator implements Comparator<Car> {
        public int compare(Car c1, Car c2) {
            String a1 = c1.color;
            String a2 = c2.color;
            return a1.compareTo(a2);
        }
    }

    public static void main(String[] args) {
        List<Car> carList = new ArrayList<>();
        List<String> sortOrder = new ArrayList<>();

        carList.add(new Car("Ford","Silver"));
        carList.add(new Car("Tes","Blue"));
        carList.add(new Car("Honda","Magenta"));

        sortOrder.add("Silver");
        sortOrder.add("Magenta");
        sortOrder.add("Blue");

        // Now here I am confuse how to implement my custom sort             
    }
}

Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
z7sg Ѫ

Ich empfehle Ihnen, eine Aufzählung für Ihre Autofarben zu erstellen, anstatt Strings zu verwenden, und die natürliche Reihenfolge der Aufzählung ist die Reihenfolge, in der Sie die Konstanten deklarieren.

public enum PaintColors {
    SILVER, BLUE, MAGENTA, RED
}

und

 static class ColorComparator implements Comparator<CarSort>
 {
     public int compare(CarSort c1, CarSort c2)
     {
         return c1.getColor().compareTo(c2.getColor());
     }
 }

Sie ändern den String in PaintColor und dann wird Ihre Autoliste im Wesentlichen zu:

carList.add(new CarSort("Ford Figo",PaintColor.SILVER));

...

Collections.sort(carList, new ColorComparator());

  • Wie würde ich dieses Beispiel ausführen. Auf PaintColors wird in ColorComparator nicht zugegriffen. Könnten Sie veranschaulichen, wie die Hauptmethode aussehen würde.

    – Deepak

    9. März 2011 um 11:42 Uhr

  • was ist die ausgabe? ist es immer zuerst SILBER?

    – Deepak

    9. März 2011 um 11:49 Uhr

  • @Deepak: ja, die natürliche Reihenfolge von enum values ​​ist die Reihenfolge, in der seine Werte definiert sind.

    – Joachim Sauer

    9. März 2011 um 12:17 Uhr

  • @SeanPatrickFloyd Ich denke nicht, dass es eine bewährte Methode ist, sich auf die natürliche Reihenfolge von Aufzählungen zu verlassen.

    – Mike

    15. Oktober 2015 um 15:11 Uhr

  • @mike Ich bin anderer Meinung, aber es gibt gültige Argumente für beide Standpunkte

    – Sean Patrick Floyd

    15. Oktober 2015 um 15:28 Uhr

1646307426 941 Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
Sean Patrick Floyd

Wie wäre es damit:

List<String> definedOrder = // define your custom order
    Arrays.asList("Red", "Green", "Magenta", "Silver");

Comparator<Car> comparator = new Comparator<Car>(){

    @Override
    public int compare(final Car o1, final Car o2){
        // let your comparator look up your car's color in the custom order
        return Integer.valueOf(
            definedOrder.indexOf(o1.getColor()))
            .compareTo(
                Integer.valueOf(
                    definedOrder.indexOf(o2.getColor())));
    }
};

Grundsätzlich stimme ich zu, dass die Verwendung von an enum ist ein noch besserer Ansatz, aber diese Version ist flexibler, da Sie verschiedene Sortierreihenfolgen definieren können.

Aktualisieren

Guave hat diese Funktionalität in seine eingebaut Ordering Klasse:

List<String> colorOrder = ImmutableList.of("red","green","blue","yellow");
final Ordering<String> colorOrdering = Ordering.explicit(colorOrder);
Comparator<Car> comp = new Comparator<Car>() {
    @Override
    public int compare(Car o1, Car o2) {
        return colorOrdering.compare(o1.getColor(),o2.getColor());
    }
}; 

Diese Version ist etwas weniger ausführlich.


Erneut aktualisieren

Java 8 macht den Comparator noch weniger ausführlich:

Comparator<Car> carComparator = Comparator.comparing(
        c -> definedOrder.indexOf(c.getColor()));

  • Kannst du bitte auch dieser Frage nachgehen. Danke.stackoverflow.com/questions/61934313/…

    – Benutzer2048204

    21. Mai 2020 um 12:17 Uhr


  • Comparator<Car> carComparator = Comparator.comparing( c -> definedOrder.indexOf(c.getColor())); wirft Kompilierungsfehler

    – Brooklyn99

    13. November 2020 um 7:44 Uhr


  • @SantosshKumhar hier ist ein funktionierendes Beispiel: ideone.com/frUbym

    – Sean Patrick Floyd

    14. November 2020 um 14:35 Uhr

1646307426 741 Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
Silvio Troia

Komparator in Linie …

List<Object> objList = findObj(name);
Collections.sort(objList, new Comparator<Object>() {
    @Override
    public int compare(Object a1, Object a2) {
        return a1.getType().compareToIgnoreCase(a2.getType());
    }
});

1646307426 642 Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
ilalex

Ich denke, das kann man wie folgt machen:

class ColorComparator implements Comparator<CarSort>
{
    private List<String> sortOrder;
    public ColorComparator (List<String> sortOrder){
        this.sortOrder = sortOrder;
    }

    public int compare(CarSort c1, CarSort c2)
    {
        String a1 = c1.getColor();
        String a2 = c2.getColor();
        return sortOrder.indexOf(a1) - sortOrder.indexOf(a2);
     }
 }

Verwenden Sie zum Sortieren Folgendes:

Collections.sort(carList, new ColorComparator(sortOrder));

1646307427 631 Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
matt1616

Ich musste etwas Ähnliches wie die Antwort von Sean und Ilalex tun.
Aber ich hatte zu viele Optionen, um die Sortierreihenfolge explizit zu definieren, und musste nur bestimmte Einträge an den Anfang der Liste verschieben … in der angegebenen (nicht natürlichen) Reihenfolge.
Hoffentlich ist dies hilfreich für jemand anderen.

public class CarComparator implements Comparator<Car> {

    //sort these items in this order to the front of the list 
    private static List<String> ORDER = Arrays.asList("dd", "aa", "cc", "bb");

    public int compare(final Car o1, final Car o2) {
        int result = 0;
        int o1Index = ORDER.indexOf(o1.getName());
        int o2Index = ORDER.indexOf(o2.getName());
        //if neither are found in the order list, then do natural sort
        //if only one is found in the order list, float it above the other
        //if both are found in the order list, then do the index compare
        if (o1Index < 0 && o2Index < 0) result = o1.getName().compareTo(o2.getName());
        else if (o1Index < 0) result = 1;
        else if (o2Index < 0) result = -1;
        else result = o1Index - o2Index;
        return result;
    }

//Testing output: dd,aa,aa,cc,bb,bb,bb,a,aaa,ac,ac,ba,bd,ca,cb,cb,cd,da,db,dc,zz
}

1646307427 124 Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
MariuszS

Ich werde so etwas tun:

List<String> order = List.of("Red", "Green", "Magenta", "Silver");

Comparator.comparing(Car::getColor(), Comparator.comparingInt(c -> order.indexOf(c)))

Alle Credits gehen an @Sean Patrick Floyd 🙂

Wie verwende ich Comparator um eine benutzerdefinierte Sortierreihenfolge zu definieren
Thermech

In Java 8 können Sie so etwas tun:

Sie benötigen zuerst ein Enum:

public enum Color {
    BLUE, YELLOW, RED
}

Autoklasse:

public class Car {

    Color color;

    ....

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

Und dann können Sie mit Ihrer Autoliste einfach Folgendes tun:

Collections.sort(carList, Comparator:comparing(CarSort::getColor));

  • Dies ist keine benutzerdefinierte Sortierung.

    – Zygimantus

    12. April 2017 um 11:19 Uhr

  • Außerdem ist es keine “funktionale” Art, es zu tun … das hat Nebenwirkungen !!

    – TriCore

    16. November 2017 um 4:39 Uhr

922970cookie-checkWie verwende ich Comparator, um eine benutzerdefinierte Sortierreihenfolge zu definieren?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy