array.sort mit zwei Kriterien

[Thongall]

Hallo,
ich habe ein Problem beim Sortieren von Objekt Arrays.

Ich möchte ein Array von Objekten mit zwei comparatoren sortieren.

Dazu vergleiche ich in jedem comparator den Wert nach dem Sortiert werden soll.
Im Hauptprogramm rufe ich dann Array.sort mit dem jeweiligen comparator auf.
Soweit kein Problem. Allerdings möchte ich das wenn ich nach dem ersten Wert sortiere und der Wert bei 2 Objekten gleich ist dann als zweites Kriterium den zweiten comparator nutzen.

Meine Idee war nun das sich die comparatoren einfach jeweils gegenseitig aufrufen.
Das klappt auch soweit außer natürlich wenn die Werte bei beiden comparatoren gleich sind - dann endet die Rekursion nie. Mein Problem ist nun das ich nicht weiß wo ich die return 0 zum Abbrechen einfügen soll oder ob es dafür generell eine andere Möglichkeit gibt.
Denn setz ich das return 0 vor dem rekursiven Aufruf wird dieser niemals ausgeführt, setz ich sie danach wird das return 0 niemals erreicht bei zwei gleichen werten.

über einen kleinen Denkanstoß wäre ich sehr dankbar.

MfG
Thongall

 

[Joose]

Deine Idee klingt schon richtig. Der Fehler ist nur

.... das sich die comparatoren einfach jeweils gegenseitig aufrufen ....

das klingt schon nach Endlosschleife

Du vergleichst den 1.Wert von 2 Objekten, wenn dieser gleich ist wird der andere Comparator aufgerufen. Dieser vergleicht nun den 2.Wert, wenn dieser wieder gleich ist dann musst du entscheiden welches nun "größer"/"kleiner" ist. Also entweder lässt du die Reihenfolge so wie sie ist wenn beide Werte gleich sind, oder du tauschst sie einfach.

 

[Flown]

Ohne Code kann dir hier keiner helfen!

Du hast Glück das ich so ähnlichen Code herumliegen habe und ich dir ein kleines KSKB basteln konnte:

Spoiler: KSKB

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;

public class TupleCompareTest {
	public static void main(String[] args) {
		new TupleCompareTest();
	}
	
	public TupleCompareTest() {
		List<Tuple> tuples = new ArrayList<>();
		for(int i = 0; i < 10; i++) {
			tuples.add(new Tuple(createRandomInt(), createRandomInt()));
		}
		printList(tuples);
		Collections.sort(tuples, new TupleComparatorX(new TupleComparatorY()));
		printList(tuples);
	}
	
	private int createRandomInt() {
		Random rnd = new Random();
		int nr = rnd.nextInt(10);
		return rnd.nextBoolean() ? nr : Math.negateExact(nr);
	}
	
	private void printList(List<Tuple> list) {
		list.forEach(e -> System.out.print(e + " "));
		System.out.println();
	}
	
	class Tuple {
		public int x, y;
		public Tuple(int x, int y) {
			this.x = x;
			this.y = y;
		}
		@Override
		public String toString() {
			return String.format("(%d, %d)", x, y);
		}
	}
	
	class TupleComparatorY implements Comparator<Tuple>{
		@Override
		public int compare(Tuple o1, Tuple o2) {
			return o1.y - o2.y;
		}
	}
	
	class TupleComparatorX implements Comparator<Tuple>{
		
		private TupleComparatorY tcy;
		
		public TupleComparatorX(TupleComparatorY tcy) {
			this.tcy = tcy;
		}
		
		@Override
		public int compare(Tuple o1, Tuple o2) {
			if(o1.x == o2.x) return tcy.compare(o1, o2);
			return o1.x - o2.x;
		}
	}
}

 

[Thongall]

Vielen Dank schonmal für die Antworten - versteh jetzt schon deutlich mehr wie eben über die Funktionsweise. Ein Problem besteht aber weiterhin.

Ich würde gerne entweder nach comperator a oder nach comperator b soriteren lassen und dann zusätlich jeweils nach dem anderem als zweites Kriterium.

Bei dem Beispiel bzw. der Erklärung klappt das immer nur in eine Richtung - hab es versucht ein wenig zu modifizieren aber lande dann wieder in der Endlos Rekursion... :/

Als Code Beispiel hab ich jetzt den Code von Flown. Dort kann man nach x und dann y sortieren oder wenn man es umschreibt umgekehrt - aber nicht beides gleichzeitig.

Also z.b. Hab ich ein Array und mache davon eine Kopie. Das Original will ich nach x und dann nach y Sortieren lassen und die Kopie nach y und dann nach x.

Edit:
Habs gelöst
Man muss gar nicht den anderen Comperator aufrufen sondern einfach beide vergleiche in der Reihenfolge wie man sie haben will im jeweiligen Comperator durchführen.
Thema ist damit erledigt, vielen Dank für die Hinweise

 

[Joose]

Ich würde gerne entweder nach comperator a oder nach comperator b soriteren lassen und dann zusätlich jeweils nach dem anderem als zweites Kriterium.

Bei dem Beispiel bzw. der Erklärung klappt das immer nur in eine Richtung - hab es versucht ein wenig zu modifizieren aber lande dann wieder in der Endlos Rekursion... :/

......................
Habs gelöst
Man muss gar nicht den anderen Comperator aufrufen sondern einfach beide vergleiche in der Reihenfolge wie man sie haben will im jeweiligen Comperator durchführen.
Thema ist damit erledigt, vielen Dank für die Hinweise

(wenn ich die richtig verstanden habe ;-))

Nein so kombinierst du die Vergleiche nicht wirklich schon miteinander! Für jede Kombination müsstest du dann einen eigenen Comparator schreiben, was vielleicht unübersichtlich und sehr viel werden könnte.

Schöner wäre eine abstrakte Basisklasse für deine Comparatoren, diese implementiert das Interface Compareable und kann ein Objekt von sich selber speichern.
In den spezifischen Klassen, implementierst du die compare Methode, und wenn für 2 Objekte der geprüfte Wert gleich ist, dann prüfst du ob der Comparator einen Referenz auf einen weiteren hat, wenn ja leitest du den vergleich weiter, ansonsten gibst du 0 zurück(oder was eben rauskommt).

So kannst du die Reihenfolge in der die Werte überprüft werden einfach ändern ohne die Methoden anzupassen

 

[Thongall]

Gut das wäre natürlich eine noch bessere Lösung - hab auch gar nicht an mehr als 2 vergleiche gedacht aber stimmt das wird dann irgendwann sehr unschön... danke für den Hinweis

 

[strußi]

sortier doch erst nach dem ersten kriterium und
lauf dann mit einem for-schleife über die objects drüber und schau wenn obj1.kriterium =obj2.kriterium
k2o1 =getobj1.kriterium 2 und k2o2 =getobj2.kriterium k2o1 <= |> k2o2

 

[DrZoidberg]

Hier ist noch ein anderer Ansatz mit lambdas.

Damit kannst du eine Liste nach beliebig vielen Kriterien sortieren.

Spoiler: Code

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

public class Test {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
            new Person("peter", "griffin"),
            new Person("homer", "simpson"),
            new Person("kyle", "broflovski"));
        
        Collections.sort(list, Comparator.comparing(p -> new CompList(p.lastName, p.firstName)));
        
        for(Person p: list) System.out.println(p);
    }
    
    static class Person {
        String firstName;
        String lastName;
        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
        
        @Override
        public String toString() {
            return firstName + " " + lastName;
        }
    }
    
    static class CompList implements Comparable<CompList> {
        ArrayList<Comparable<?>> list = new ArrayList<>();
        CompList(Comparable<?> ... elems) {
            for(Comparable<?> elem: elems) list.add(elem);
        }
        
        @SuppressWarnings("unchecked")
        public int compareTo(CompList other) {
            for(int i = 0; i < list.size() && i < other.list.size(); i++) {
                Comparable elem1 = list.get(i);
                Comparable elem2 = other.list.get(i);
                int c = elem1.compareTo(elem2);
                if(c < 0) return -1;
                else if(c > 0) return 1;
            }
            if(list.size() < other.list.size()) return -1;
            else if(list.size() > other.list.size()) return 1;
            else return 0;
        }
    }
}

 

[nvidia]

Würde ich eine Liste von Personen haben und die nach Vor-/Nachname aufsteigend sortieren wollen, d.h. aus [(c,b) (c,a)] soll die Reihenfolge [(c,a) (c,b)] werden, wobei der erste Wert des Tupels dem Nachnamen und der zweite Wert des Tupels dem Vornamen entspricht, würde ich folgende Zeile verwenden.

 list.sort(comparing(Person::lastName).thenComparing(Person::firstName));