Comparator (steh wohl aufm Schlauch)

[Verjigorm]

Hallo,

ich denke, irgendwie steh ich grad aufm Schlauch, was den Comparator betrifft.
Hab mir grad nochmal das Beispiel in der FAQ angeschaut, sowie rumgegoogelt.
Aber irgendwie isses anders wie ich mir es vorgestellt habe.
Ein Kleines Beispiel:
Liste mit Chars/Strings: [A, C, E, G, I]
Ich möchte nun, dass sortiert wird, dass das "E" immer an erster Stelle steht -> [E, A, C, G, I]

Dabei kam jetzt folgender unten stehender (funktionierender) Code raus.
ABER eigentlich war ich der Meinung, das die if-Abfrage ein -1 zurückgeben müsste, weil ja mein "E" immer "kleiner" sein soll, als der andere
Aber funktioniert nicht. Stehe ich da irgendwie aufm Schlauch?
Klärt mich mal jemand bitte auf?

mfg Verjigorm

package comparatortest;

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

public class ComparatorTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		List<String> list = new ArrayList<String>();
		list.add("A");
		list.add("C");
		list.add("E");
		list.add("G");
		list.add("I");
		
		System.out.println(list);
		
		Collections.sort(list, new Comparator<String>()
		{

			@Override
			public int compare(String o1, String o2) 
			{
				if(o2.equals("E"))
					return 1;
				
				return o1.compareTo(o2);
			}
			
		});
		
		System.out.println(list);
	}
}

 

[tfa]

Lies dir in der API durch, was compare() zurück gibt und dann lass dir ausgeben, was compareTo() für die verglichenen Strings liefert.

 

[Verjigorm]

The result is a negative integer if this String object lexicographically precedes the argument string. The result is a positive integer if this String object lexicographically follows the argument string. The result is zero if the strings are equal...

Für mich heisst das:

A < B => Negativ
A == B => 0
A > B => Positiv

In dem Fall hier ist doch genau mein E "kleiner als alle anderen", also müsste ich doch was negatives zurückgeben

 

[tfa]

Du hast vergessen, dass das E ja auch als erstes Argument o1 übergeben werden kann. Vertausch mal in deiner Anfangsliste A und I.

 

[Verjigorm]

Das da noch ein

				if(o1.equals("E"))
					return -1;

hinkommt ist mir klar und verstehe ich auch, aber ich verstehe den ersten positiven returnwert nicht

 

[Beni]

Es kann positiv sein, weil dieser Wert zeigt welches Zeichen ">", "<" oder "=" zwischen den Werten steht.

Beweis:

A < B => Negativ
A == B => 0
A > B => Positiv

A könnte "E" sein, B könnte "E" sein, beide könnten "E" sein, oder keiner.
Dann gibt insgesammt vier Varianten wie das zusammenkommt:

o1 = "E", o2 = "x": o1 < o2 -> -1
o1 = "x", o2 = "E": o1 > o2 -> 1
o1 = "E", o2 = "E": o1 = o2 -> 0
o1 = "x", o2 = "x": o1 <=> o2 -> ?

 

[Verjigorm]

Jo, das ist ja klar, aber "E" soll IMMER kleiner sein als alle, also wieso muss da ein return 1? hin anstatt einem return -1; ?
Verstehe ich net...

 

[Beni]

Nochmal zum mitschreiben.

Setzen wir o1 = "x" wobei "x" nicht "E" ist.

Setzen wir o2 = "E"

Vergleichen wir o1 mit o2.

Bemerken wir o2 < o1 weil "E" < "x"

Wenden wir einfachste mathematische Grundkentnisse an. Aus o2 < o1 machen wir o1 > o2. Denn aus "E" < "x" folgt auch "x" > "E".

Lesen wir die API-Doc von "compare" nochmal durch und bemerken wir, dass der Rückgabewert genau den Zeichen "<", "=" und ">" zwischen o1 und o2 entsprecht.

Betrachten wir nocheinmal unser Beispiel: o1 > o2 weil "x" > "E".

Benutzen wir folgende Übersetzung: "=" = 0, "<" = -1, ">" = 1.

Also sehen wir ">" ist 1.

Also geben wir 1 zurück.

 

[tfa]

Wie du geschrieben hast: A > B => Positiv
B ist o2, wenn o2==B=="E" muss "E" kleiner sein, also A>B, also positiv.

 

[Verjigorm]

Kann ich alles nachvollziehen,
aber "E" soll IMMER "<" sein, also müsste bei

            if(o2.equals("E"))
               return 1;

doch logischerweise -1 stehen :autsch:
Ich verstehs nicht

Wenn es doch ">" wär müsste es in der liste doch weiter "rechts" stehen
oder sehe ich das falsch?

 

[tfa]

"A".compareTo("E")

ergibt -4, denn "A" ist kleiner als "E".
Wenn "E" jetzt aber kleiner als "A" sein soll, muss das Ergebnis umgekehrt sein, also z.B. +4 (jedenfalls positiv).

Man kann's auch so interpretieren:

Für aufsteigende Sortierreihenfolge
- Wert negativ: Reihenfolge der Elemente kann so bleiben.
- Wert positiv: Reihenfolge der Elemente muss getauscht werden.

Wenn dein "E" an Position 2 steht, muss immer getauscht werden.

 

[Verjigorm]

"A".compareTo("E")

ergibt -4, denn "A" ist kleiner als "E".
Wenn "E" jetzt aber kleiner als "A" sein soll, muss das Ergebnis umgekehrt sein, also z.B. +4 (jedenfalls positiv).

Man kann's auch so interpretieren:

Für aufsteigende Sortierreihenfolge
- Wert negativ: Reihenfolge der Elemente kann so bleiben.
- Wert positiv: Reihenfolge der Elemente muss getauscht werden.

Wenn dein "E" an Position 2 steht, muss immer getauscht werden.

Ach herrje, nun hats klick gemacht....
Vielen Dank euch beiden für die Geduld

 

[Soi]

:###