3 Comparatoren zu einem zusammenfassen - Chaining...

[handshake45]

Habt ihr einen allgemeinen Ansatz wie man mehrere Comparatoren zusammenfassen tut?:

Collections.sort(trades, new Comparator<MyTrade>() {
	@Override
	public int compare(MyTrade o1, MyTrade o2) {
		return (int) (o2.profit - o1.profit);
	}
});
Collections.sort(trades, new Comparator<MyTrade>() {
	@Override
	public int compare(MyTrade o1, MyTrade o2) {
		int d1 = (int) (o1.sysDis / 10f);
		int d2 = (int) (o2.sysDis / 10f);
		return d1 - d2;
	}
});
Collections.sort(trades, new Comparator<MyTrade>() {
	@Override
	public int compare(MyTrade o1, MyTrade o2) {
		float f1 = getSysDis(o1.buyItem.sta.sys, lhs22);
		float f2 = getSysDis(o2.buyItem.sta.sys, lhs22);
		if (f1 > 75) {
			if (f2 > 75) {
				return 0;
			} else {
				return +1;
			}
		} else {
			if (f2 > 75) {
				return -1;
			} else {
				return 0;
			}
		}
	}
});

... möchte gerne nur einen sort Aufruf, mit demselben Effekt...

 

[thecain]

Mit thenComparing müsste das seit Java 8 gehen

 

[handshake45]

Ja das wäre eine Idee...

 

[handshake45]

Lassen sich auch Pärchen sortieren? Es gibt zu jedem Listenelement ein dazugehöriges zweites Element in der gleichen Liste.... Wenn möglich, soll nur eins davon für die Sortierung gewählt werden und falls es verschoben wird, sollen die Pärchen zusammenbleiben. Versteht man was ich meine? Ist das möglich? Oder muss aus jeweils zwei Elementen zuvor ein neues gemacht werden?

 

[handshake45]

Hat keiner eine Idee?

 

[kneitzel]

Halte Deine Daten sauber: Wenn du Pärchen hast, dann solltest Du Pärchen haben und nicht irgendwas zusammen hacken.

Du kannst aber natürlich eine kleine Klasse machen, die dein Array enthält und entsprechend die Daten kapselt. Dann hast Du nach außen die Pärchen und innen halt deine Liste ...

Aber wie im ersten Satz gesagt: Überdenke das Design und was Du da wieso machst ....

 

[handshake45]

Ja die Pärchen stehen anfangs zusammen in der Liste, also an Platz 13 zum Beispiel a und an Platz 14 b... Durch die Umsortierung der Elemente so nenne ich es mal ändert sich die Reihenfolge der Pärchen, so dass a jetzt zum Beispiel auf Platz 4 ist und b auf Platz 40. Schön wäre es aber wenn (a, b) entweder auf den Plätzen 4 und 5 stehe oder auf den Plätzen 40 und 41. Gibt es da nicht irgendeinen Trick oder "Hack" um das zu erreichen, ohne dass ich eine neue Klasse einführe?:

class MyTradPair {
    MyTrade a, b;
    // ...
}

 

[LimDul]

Was spricht den gegen eine neue Klasse? Wenn der Aspekt aktuell nicht in deinen Daten abgebildet ist, dann ist das Modell nicht ideal => Modell erweitern.

 

[handshake45]

Ok dann brauche ich doch eine neue Klasse/Objekt

 

[LimDul]

Ansonsten bräuchtest du halt bei einem Comparator, der bei den Objeten, die zum gleichen Paar gehören 0 liefert und sonst einen Wert != 0.

 

[handshake45]

Wäre das denkbar?:

	@Override
	public int compareTo(MyTrade o) {
		if (buyItem.sta.name.equals(o.sellItem.sta.name) && sellItem.sta.name.equals(o.buyItem.sta.name)) {
			return 0;
		}
		int d1 = (int) (sysDis / 10f);
		int d2 = (int) (o.sysDis / 10f);
		if (d1 == d2) {
			return (int) (o.profit - profit);
		}
		return d1 - d2;
	}

 

[LimDul]

Kann gehen. Die Frage ist, erfüllen deine Paar-Items auch die Transitivität.

Sprich, wenn buyitem und sellitem identisch sind und X ein drittes Item ist für das gilt x < buyitem, gilt dann auch in dem Comparator x < sellitem?

Das muss natürlich gelten. Ansonsten kommt Murks raus.

 

[handshake45]

erfüllen deine Paar-Items auch die Transitivität

Nein leider nicht

 

[LimDul]

Dann ist die Anforderung nicht erfüllbar. Wenn gilt a und b bilden Paar und sollen daher zusammen sortiert werden und c ist kleiner als a, aber größer als b verletzen alle Möglichen Sortierreihenfolge eine der Bedingungen.

 

[handshake45]

Dann muss ich die jeweils zusammengehörigen Elemente doch wegkapseln... und mich für ein Sortierkriterium, das für beide gilt, entscheiden.

Danke dir!

 

[handshake45]

Habe eine Verallgemeinerung gefunden! Man ruft in compareTo() die Vergleichsmethoden in umgekehrter Reihenfolge auf...

class MyTrade implements Comparable<MyTrade> {
	static MySys lhs22 = null;

	MyItem buyItem = null;
	MyItem sellItem = null;

	long profit;
	float sysDis;
	float dtstar1;
	float dtstar2;

	MyTrade(MyItem[] items) {
		buyItem = items[0];
		sellItem = items[1];
		profit = sellItem.price - buyItem.price;
		sysDis = EP.getSysDis(buyItem.sta.sys, sellItem.sta.sys);
		dtstar1 = buyItem.sta.dtstar;
		dtstar2 = sellItem.sta.dtstar;
	}

	int compare1(MyTrade o1, MyTrade o2) {
		return (int) (o2.profit - o1.profit);
	}

	int compare2(MyTrade o1, MyTrade o2) {
		int d1 = (int) (o1.sysDis / 10f);
		int d2 = (int) (o2.sysDis / 10f);
		return d1 - d2;
	}

	int compare3(MyTrade o1, MyTrade o2) {
		float f1 = EP.getSysDis(o1.buyItem.sta.sys, lhs22);
		float f2 = EP.getSysDis(o2.buyItem.sta.sys, lhs22);
		int threshold = 100;
		if (f1 > threshold) {
			if (f2 > threshold) {
				return 0;
			} else {
				return +1;
			}
		} else {
			if (f2 > threshold) {
				return -1;
			} else {
				return 0;
			}
		}
	}

	@Override
	public int compareTo(MyTrade o) {
		int c = compare3(this, o);
		if (c == 0) {
			c = compare2(this, o);
			if (c == 0) {
				c = compare1(this, o);
			}
		}
		return c;
	}
}

class MyTrade2 implements Comparable<MyTrade2> {
	MyTrade a, b;

	MyTrade2(MyTrade t1, MyTrade t2) {
		if (t2 != null) {
			if (t1.compareTo(t2) > 0) {
				MyTrade t3 = t1;
				t1 = t2;
				t2 = t3;
			}
		}
		a = t1;
		b = t2;
	}

	@Override
	public int compareTo(MyTrade2 o) {
		return this.a.compareTo(o.a);
	}
}

und so befülle ich die Listen:

				ArrayList<MyTrade> trades = new ArrayList<MyTrade>();
				for (MySta sta1 : newSta.values()) {
					for (MySta sta2 : newSta.values()) {
						if (sta1.id == sta2.id)
							continue;
						MyItem[] items1 = getBestItems(sta1, sta2);
						if (items1 != null) {
							trades.add(new MyTrade(items1));
						}
					}
				}
				MySys lhs22 = ...
				MyTrade.lhs22 = lhs22;
				ArrayList<MyTrade2> trades2 = new ArrayList<MyTrade2>();
				while (!trades.isEmpty()) {
					MyTrade a = trades.remove(0);
					MyTrade c = null;
					for (int i = 0; i < trades.size(); i++) {
						MyTrade b = trades.get(i);
						if (a.buyItem.sta.id == b.sellItem.sta.id && a.sellItem.sta.id == b.buyItem.sta.id) {
							trades.remove(i);
							c = b;
							break;
						}
					}
					trades2.add(new MyTrade2(a, c));
				}
				Collections.sort(trades2);

Eigentlich easy going oder?