Sortieren

[javacc123]

Wenn ich eine Klasse besitze mit mehreren Attributen und ich diese nach einem bestimmten Schema sortieren möchte, muss ich ja die Klasse Comparable nehmen.
Die andere Möglichkeit wäre es ja einen eigenen Comparator als Klasse zu erstellen.
Wie kann ich dort dynamisch(zur Laufzeit) sortieren? Z.B. ob ich aufsteigend oder absteigend sortiert werden soll, möchte ich zur Laufzeit festlegen können.

mfg

 

[redJava99]

Du kannst dem Comparator bei der Instanzierung die entsprechenden Parameter zum Sortieren mitgeben und diese in der Implementierung von compare() entsprechend berücksichtigen.

z.B.:

public class PersonComparator implements Comparator<Person> {

    private OrderPolicy order;

    public PersonComparator(OrderPolicy order) {
        this.order = order;
    }
   
    @Override
    public int compare(Person p1, Person p2) {
                int lastnameRes = p1.getLastName().compareTo(p2.getLastName());
                if (lastnameRes!= 0) {
                    return lastnameRes * order.multiplicand;
                }
        return p1.getFirstName().compareTo(p2.getFirstName()) * order.multiplicand;
    }

    public enum OrderPolicy {

        ASCENDING(1), DESCENDING(-1);

        private int multiplicand;
        private OrderPolicy(int m) {
            multiplicand = m;
        }
    }
}

Der Comparator lässt sich verwenden, um eine Liste mit Personen nach ihrem Nach- und Vornamen zu sortieren - wahlweise auf-oder absteigend:

List<Person> persons;
//...
Collections.sort(persons, new PersonComparator(PersonComparator.OrderPolicy.ASCENDING);

 

[InfectedBytes]

Entweder du nutzt einfach zwei verschiedene Comparatoren oder:
Wenn du dir eine Comparator Klasse erstellt hast, kannst du dort einfach nen Attribut anlegen und beim vergleich folgendes machen:

public class MyComparator implements Comparator<XYZ> {
  public boolean backwards; // besser mit getter/setter
  public int compare(XYZ a, XYZ b) {
    int result = 0;
    // a und b vergleichen und das ergebnis in result speichern, z.b.
    if(a.wert > b.wert) result = 1;
    if(backwards) return -result;
    return result;
  }
}

 

[javacc123]

public enum OrderPolicy {

        ASCENDING(1), DESCENDING(-1);

        private int multiplicand;
        private OrderPolicy(int m) {
            multiplicand = m;
        }
    }
}

Das verstehe ich nicht ganz.
In dieser Methode lässt sich entscheiden ob ich aufsteigend oder absteigend sortieren möchte, indem ich 1 oder -1 angebe?
Aber die Methode hat noch nichts mit dem Comparator ansich zutun, oder irre ich mich ?

 

[redJava99]

Nein, die 1 und -1 sind fix. Die "Methode", die du ansprichts, ist der Konstruktor des enums.
Ob du auf- oder absteigend sortierst, entscheidest du beim Erstellen des Comparators:

//aufsteigend
new PersonComparator(PersonComparator.OrderPolicy.ASCENDING)

//absteigend
new PersonComparator(PersonComparator.OrderPolicy.DESCENDING)

-1 / +1 hat mehr den Mathematischen Hintergrund, dass ich für DESCENDING (= -1) das Vorzeichen des compare()-Ergebnisses umdrehe, um die Reihenfolge zu invertieren.
Die Alternative wäre if(order == DESCENDING){return -result;}, so ählich wie InfectedBytes es gelöst hat.

 

[javacc123]

Entweder du nutzt einfach zwei verschiedene Comparatoren oder:
Wenn du dir eine Comparator Klasse erstellt hast, kannst du dort einfach nen Attribut anlegen und beim vergleich folgendes machen:

public class MyComparator implements Comparator<XYZ> {
  public boolean backwards; // besser mit getter/setter
  public int compare(XYZ a, XYZ b) {
    int result = 0;
    // a und b vergleichen und das ergebnis in result speichern, z.b.
    if(a.wert > b.wert) result = 1;
    if(backwards) return -result;
    return result;
  }
}

Verstehe auch nicht den Sinn ganz, wie kann ich dann hier zur Laufzeitangeben, ob ich auf oder absteigend sortieren möchte?

Hier mal ein Beispeil wie ich das genauer meine:

public class Auto {
  private String Marke;
  private double verbrauch;

//getter-Setter Methoden..

Jetzt möchte ich z.B. erst nach Marke vergleichen und dann, wenn sie der gleichen marke angehören noch nach verbrauch sortieren. Den Verbrauch will ich dann dynamisch festlegen.

Mein Versuch:

public class Comp implements Comparator<Auto>

  public int compare(Auto a1, Auto a2) {
       int x = a1.getMarke().compare(a2.getMarke());
       if (x == 0)
         return a1.getVerbrauch().compare(a2.getVerbrauch());
       else
         return x;
     }

So sortiert er ja nach Marke und falls es gleich ist, dann nach Verbrauch.
Aber das mit dem Verbrauch ist ja nicht dynamisch und wird in dem Fall doch nur aufsteigend sortiert.

 

[javacc123]

Nein, die 1 und -1 sind fix. Die "Methode", die du ansprichts, ist der Konstruktor des enums.
Ob du auf- oder absteigend sortierst, entscheidest du beim Erstellen des Comparators:

//aufsteigend
new PersonComparator(PersonComparator.OrderPolicy.ASCENDING)

//absteigend
new PersonComparator(PersonComparator.OrderPolicy.DESCENDING)

-1 / +1 hat mehr den Mathematischen Hintergrund, dass ich für DESCENDING (= -1) das Vorzeichen des compare()-Ergebnisses umdrehe, um die Reihenfolge zu invertieren.
Die Alternative wäre if(order == DESCENDING){return -result;}, so ählich wie InfectedBytes es gelöst hat.

Steh grad auf dem Schlauch.
Fehlt hier nicht noch die Methode Compare bei dem aufruf?
new PersonComparator(PersonComparator.OrderPolicy.ASCENDING)
Oder wie wird auf diese zugegriffen?

Ansonsten versteh ich dein Prinzip beim erstellen, würde es gerne noch direkt beim Code von Comparator haben.

 

[redJava99]

Der eigentliche Aufruf, um die Liste (aufsteigend) zu sortieren, ist

Collections.sort(persons, new PersonComparator(PersonComparator.OrderPolicy.ASCENDING);

Im letzten Posting hatte ich nur den Teil zum Erstellen des Comparators gepostet. Auf die compare-Methode wird in der Implementierung von Collections#sort() zugegriffen; die wird also von dir nicht explizit aufgerufen.

würde es gerne noch direkt beim Code von Comparator haben.

Was ist "es"? Mehr lässt sich da nicht in den Comparator auslagern.

 

[javacc123]

Der eigentliche Aufruf, um die Liste (aufsteigend) zu sortieren, ist

Collections.sort(persons, new PersonComparator(PersonComparator.OrderPolicy.ASCENDING);

Im letzten Posting hatte ich nur den Teil zum Erstellen des Comparators gepostet. Auf die compare-Methode wird in der Implementierung von Collections#sort() zugegriffen; die wird also von dir nicht explizit aufgerufen.


Was ist "es"? Mehr lässt sich da nicht in den Comparator auslagern.

Damit mein ich den Comparator
Dann versuch ich das gleich nochmal mit meinem Beispiel und einer direkt IF-Anweisung.

 

[javacc123]

public class Comp implements Comparator<Auto>
 boolean backwards;
  public int compare(Auto a1, Auto a2) {
       int x = a1.getMarke().compare(a2.getMarke());
       if (x == 0)    
x = a1.getVerbrauch().compare(a2.getVerbrauch());
if(a1.getVerbrauch()>a2.getVerbrauch())
x = 1;
if(backwards) 
return -x;

else
         return x;
     }

Würde das so gehen? Und ich müsste dann immer noch bestimmen oder backwards eben true oder falls ist?
Also z.B absteigend sortieren mache ich von boolean backwards auf true?

 

[javacc123]

passt das so?

 

[Flown]

So ich muss hier mich mal einmischen!

Wenn man mit Java 8 arbeitet (was mittlerweile ja schon seit März 2014 existiert) dann hat man eigentlich keine Probleme mehr mit solchen Aufgaben. Dann sieht der Comparator einfach so aus:

Comparator<Car> carComparator = Comparator.comparing(Car::getMarke).thenComparingDouble(Car::getVerbrauch);
// Invertiert
Comparator<Car> reversedCarComparator = carComparator.reversed();

Wenn man das "neue" eben nicht haben will, dann geht es auf dem alten Weg so:

Comparator<Car> carComparatorJava7 = new Comparator<Car>() {
   @Override
   public int compare(Car o1, Car o2) {
     int compare = o1.getMarke().compareTo(o2.getMarke());
     if (compare == 0) {
       return Double.compare(o1.getVerbrauch(), o2.getVerbrauch());
     }
     return compare;
   }
};
Comparator<Car> reversedCarComparatorJava7 = Collections.reverseOrder(carComparatorJava7);

Damit man das ganze auch mal ausprobieren kann (natürlich Java 8 benötigt, sonst eben diverse Teile löschen):

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {

	public static final Comparator<Car> CAR_COMPARATOR = Comparator.comparing(Car::getMarke)
			.thenComparingDouble(Car::getVerbrauch);
	public static final Comparator<Car> REVERSED_CAR_COMPARATOR = CAR_COMPARATOR.reversed();

	public static final Comparator<Car> CAR_COMPARATOR_JAVA_7 = new Comparator<Car>() {
		@Override
		public int compare(Car o1, Car o2) {
			int compare = o1.getMarke().compareTo(o2.getMarke());
			if (compare == 0) {
				return Double.compare(o1.getVerbrauch(), o2.getVerbrauch());
			}
			return compare;
		}
	};

	public static final Comparator<Car> REVERSED_CAR_COMPARATOR_JAVA_7 = Collections
			.reverseOrder(CAR_COMPARATOR_JAVA_7);

	public static void main(String[] args) {
		List<Car> cars = Arrays.asList(new Car("Audi", 5.9d), new Car("Audi", 6.8), new Car("Mercedes", 9.1d));
		cars.sort(CAR_COMPARATOR);
		System.out.println(cars);
		cars.sort(REVERSED_CAR_COMPARATOR);
		System.out.println(cars);

		Collections.sort(cars, CAR_COMPARATOR_JAVA_7);
		System.out.println(cars);
		Collections.sort(cars, REVERSED_CAR_COMPARATOR_JAVA_7);
		System.out.println(cars);
	}

}

class Car {
	private String marke;
	private double verbrauch;

	public Car(String marke, double verbrauch) {
		this.marke = marke;
		this.verbrauch = verbrauch;
	}

	public String getMarke() {
		return marke;
	}

	public void setMarke(String marke) {
		this.marke = marke;
	}

	public double getVerbrauch() {
		return verbrauch;
	}

	public void setVerbrauch(double verbrauch) {
		this.verbrauch = verbrauch;
	}

	@Override
	public String toString() {
		return "Car [marke=" + marke + ", verbrauch=" + verbrauch + "]";
	}

}

 

[javacc123]

Ich lerne leider noch das "alte".
Der Comparator sieht ja so aus wie meiner, meine Frage ist nur wie ich jetzt dynamisch entscheiden kann ob ich aufsteigend oder eben absteigend sortiert haben möchte. Hab das immernoch nicht ganz gecheckt.

Stehen bei dir dafür die Konstanten?

public static final Comparator<Car> CAR_COMPARATOR_JAVA_7 = new Comparator<Car>() {

public static final Comparator<Car> REVERSED_CAR_COMPARATOR_JAVA_7 =
          Collections.reverseOrder(CAR_COMPARATOR_JAVA_7);

 

[thecain]

in einem Fall benutzt du halt den einen im anderen Fall den Anderen

 

[Flown]

Was heißt für dich dynamisch? Du musst es einfach dynamisch dann anbinden.
Z.B.: Wenn du einen Button drückst? Dann kannst du die Sortierung im ActionListener ändern.

 

[javacc123]

Ja genau das mein ich.
Also muss ich jetzt entweder ab oder aufsteigend sortierend aufrufen und dafür habe ich die Konstanten definiert, richtig?

 

[Flown]

Ein simples ja

 

[javacc123]

Entweder du nutzt einfach zwei verschiedene Comparatoren oder:
Wenn du dir eine Comparator Klasse erstellt hast, kannst du dort einfach nen Attribut anlegen und beim vergleich folgendes machen:

public class MyComparator implements Comparator<XYZ> {
  public boolean backwards; // besser mit getter/setter
  public int compare(XYZ a, XYZ b) {
    int result = 0;
    // a und b vergleichen und das ergebnis in result speichern, z.b.
    if(a.wert > b.wert) result = 1;
    if(backwards) return -result;
    return result;
  }
}

Hallo,
ich habe jetzt nochmal etwas hier rumprobiert und das hier versucht:

import java.awt.List;
import java.util.ArrayList;
import java.util.Collections;

public class Auto {
   
      private String marke;
      private int inv;
     
     
      public Auto(String m, int i) {
      this.marke = m;
      this.inv = i;
     
      }
      public String getMarke() {
      return this.marke;
      }
     
      public int getInv() {
      return this.inv;
      }
     
      public String toString() {
      return this.marke + " (" + this.inv + ")";
      }
      public static void main(String[]args){
        ArrayList<Auto> autos = new ArrayList<Auto>();
         
        autos.add(new Auto("Mercedes", 2007));
        autos.add(new Auto("Audi A8", 2010));
        autos.add(new Auto("Audi A8",2009));
       
       Collections.sort(autos, new ComparatorAuto().isBackwards());
       
        System.out.println("Sortierung nach Fahrzeugmarke:");
        for (Auto a : autos) {
        System.out.println(a);
        }
      }
     }

Dazu der Comparator:

import java.util.Comparator;

public class ComparatorAuto implements Comparator <Auto> {
   /*private boolean backwards;
   public ComparatorAuto(boolean b){
     this.backwards = b;
   }*/
   public boolean backwards;
   public boolean isBackwards() {
     return backwards;
   }
   public void setBackwards(boolean backwards) {
     this.backwards = backwards;
   }
   public int compare(Auto a1, Auto a2){
   int x = a1.getMarke().compareTo(a2.getMarke());
   if (x==0){
     
    Integer y = Integer.compare(a1.getInv(), a2.getInv());
    if(backwards){
      return -y;
    }else{
      return y;
    }
   }return x;
}

}

Das war das Beispiel von InfectedBytes.

Warum zeigt er mir jetzt einen Fehler beim Sortieren in der Zeile:
Collections.sort(autos, new ComparatorAuto().isBackwards()); an?
Warum kann ich so nicht die Gettermethode von Backwards aufrufen?

mfg

 

[VfL_Freak]

Moin,

mal ganz davon abgesehen, dass Du IMMER auch schreiben solltest, WELCHER Fehler denn aufttritt (Stacktrace poste!!) ....

Warum zeigt er mir jetzt einen Fehler beim Sortieren in der Zeile:
Collections.sort(autos, new ComparatorAuto().isBackwards()); an?
Warum kann ich so nicht die Gettermethode von Backwards aufrufen?

Du versuchst hier ein neues Objekt zu erzeugen und gleichzeitig eine Methode des Objekts aufzurufen !!
Erzeuge das gewünschte Objekt separat !

Gruß Klaus

 

[Flown]

Ich muss mich mal wieder dazuschalten. Du hast noch immer nicht verstanden, wie das mit Comparatoren von statten geht. Ich seh du hast mit den Grundlagen der OOP (evtl. Java) deine Schwierigkeiten und solltest bei denen ansetzen.
Dein backward flag macht gar nichts.

Es funktioniert eher so:

class Auto {
   
    private String marke;
    private int inv;
   
    public Auto(String m, int i) {
        this.marke = m;
        this.inv = i;
       
    }
   
    public String getMarke() {
        return this.marke;
    }
   
    public int getInv() {
        return this.inv;
    }
   
    @Override
    public String toString() {
        return this.marke + " (" + this.inv + ")";
    }
   
    public static void main(String[] args) {
        ArrayList<Auto> autos = new ArrayList<Auto>();
       
        autos.add(new Auto("Mercedes", 2007));
        autos.add(new Auto("Audi A8", 2010));
        autos.add(new Auto("Audi A8", 2009));
       
        Collections.sort(autos, new ComparatorAuto().reversed());
       
        System.out.println("Sortierung nach Fahrzeugmarke:");
        for (Auto a : autos) {
            System.out.println(a);
        }
    }
}

class ComparatorAuto implements Comparator<Auto> {
   
    private boolean reverseOrder;
   
    public ComparatorAuto() {
        this.reverseOrder = false;
    }
   
    public ComparatorAuto(boolean reverseOrder) {
        this.reverseOrder = reverseOrder;
    }
   
    public ComparatorAuto reversed() {
        return new ComparatorAuto(!reverseOrder);
    }
   
    @Override
    public int compare(Auto a1, Auto a2) {
        if (reverseOrder) {
            Auto tmp = a1;
            a1 = a2;
            a2 = tmp;
        }
        int x = a1.getMarke().compareTo(a2.getMarke());
        if (x == 0) {
            return Integer.compare(a1.getInv(), a2.getInv());
        }
        return x;
    }
}

 

[javacc123]

Moin,

mal ganz davon abgesehen, dass Du IMMER auch schreiben solltest, WELCHER Fehler denn aufttritt (Stacktrace poste!!) ....


Du versuchst hier ein neues Objekt zu erzeugen und gleichzeitig eine Methode des Objekts aufzurufen !!
Erzeuge das gewünschte Objekt separat !

Gruß Klaus

Das hat leider auch nicht so geklappt.

Ich muss mich mal wieder dazuschalten. Du hast noch immer nicht verstanden, wie das mit Comparatoren von statten geht. Ich seh du hast mit den Grundlagen der OOP (evtl. Java) deine Schwierigkeiten und solltest bei denen ansetzen.
Dein backward flag macht gar nichts.

Es funktioniert eher so:

class Auto {
  
    private String marke;
    private int inv;
  
    public Auto(String m, int i) {
        this.marke = m;
        this.inv = i;
      
    }
  
    public String getMarke() {
        return this.marke;
    }
  
    public int getInv() {
        return this.inv;
    }
  
    @Override
    public String toString() {
        return this.marke + " (" + this.inv + ")";
    }
  
    public static void main(String[] args) {
        ArrayList<Auto> autos = new ArrayList<Auto>();
      
        autos.add(new Auto("Mercedes", 2007));
        autos.add(new Auto("Audi A8", 2010));
        autos.add(new Auto("Audi A8", 2009));
      
        Collections.sort(autos, new ComparatorAuto().reversed());
      
        System.out.println("Sortierung nach Fahrzeugmarke:");
        for (Auto a : autos) {
            System.out.println(a);
        }
    }
}

class ComparatorAuto implements Comparator<Auto> {
  
    private boolean reverseOrder;
  
    public ComparatorAuto() {
        this.reverseOrder = false;
    }
  
    public ComparatorAuto(boolean reverseOrder) {
        this.reverseOrder = reverseOrder;
    }
  
    public ComparatorAuto reversed() {
        return new ComparatorAuto(!reverseOrder);
    }
  
    @Override
    public int compare(Auto a1, Auto a2) {
        if (reverseOrder) {
            Auto tmp = a1;
            a1 = a2;
            a2 = tmp;
        }
        int x = a1.getMarke().compareTo(a2.getMarke());
        if (x == 0) {
            return Integer.compare(a1.getInv(), a2.getInv());
        }
        return x;
    }
}

Ja Flown, ich habe Probleme mit der OOP.
Also klappt das sozusagen nur über den Konstruktor?
Du setzt das Attribut im ersten Konstruktor auf false.
Im 2. Konstrkutor setzt du eine Bedingung um es dann in der Methode reversed zu übergeben als neues Objekt.
Also geschieht das alles Intern über den Konstrukor, der sozusagen immer eine Bedingung (boolean reverseOrder) in sicht trägt und diese ist auf false gesetzt und erst wenn man extra die Methode reversed()aufruft wird dieser auf True gesetzt.
Deshalb kann ich auch ein Objekt des Comparators erzeugen oder die Bedingungen abzugeben, weil sie intern auf false gesetzt wird oder?

mfg

 

[Flown]

Das kannst du auch über Methoden lösen. Ist doch alles da Gleiche! Du brauchst zum Sortieren eine Instanz von einem Comparator, mehr ist das nicht. Was du dann im Comparator machst ist dann deine Sache!
Funktioniert auf 1000 Wegen:
Angenommen diesen Comparator:

class ComparatorAuto implements Comparator<Auto> {
	
	private boolean reverseOrder;
	
	public ComparatorAuto() {
		this.reverseOrder = false;
	}
	
	public ComparatorAuto(boolean reverseOrder) {
		this.reverseOrder = reverseOrder;
	}
	
	public ComparatorAuto reversed() {
		return new ComparatorAuto(!reverseOrder);
	}
	
	public void reverse() {
		this.reverseOrder = !reverseOrder;
	}
	
	@Override
	public int compare(Auto a1, Auto a2) {
		if (reverseOrder) {
			Auto tmp = a1;
			a1 = a2;
			a2 = tmp;
		}
		int x = a1.getMarke().compareTo(a2.getMarke());
		if (x == 0) {
			return Integer.compare(a1.getInv(), a2.getInv());
		}
		return x;
	}
}

Folgendes ist alles Äquivalent!

Collections.sort(autos, new ComparatorAuto().reversed());
//Oder:
ComparatorAuto ca = new ComparatorAuto();
ca.reverse();
Collections.sort(autos, ca);
//Oder:
Collections.sort(autos, Collections.reverseOrder(new ComparatorAuto()));