# [solved] Vector sortieren (Collection / Comparable?)



## w00t (15. Mai 2008)

Hallo,

also ich habe folgendes Problem:

Ich habe eine Klasse (Channel). Diese enthält eine menge Variablen.

Ich lese Daten aus, erzeuge mit denen jeweils eine Klasse Channel und füge die Klasse dann einem Vector hinzu (Vector <Channel> cList)

Nun muss ich den Vector sortieren. 
Da ich einen PHP code in Java umsetzten will, habe ich dort die Function "usort".

Dazu einen kleinen Algorithmus den ich auch schon in Java umgesetzt habe.
Hier mal ein kleiner Ausschnitt:

PHP

```
[ ... Liste erzeugen, channel erzeugen und der liste hinzufügen ... ]

 function cmp ($a, $b) {
   if ($a["order"] == $b["order"]) {
     return ($a["channelid"] < $b["channelid"]) ? -1 : 1;
   }//return 0;
   return ($a["order"] < $b["order"]) ? -1 : 1;
  }
  usort($channelList, "cmp");
  return $channelList;
}
```
Die Funktion "cmp" ist in der Funktion enthalten die die Channel erzeugt etc.

Nun habe ich erstmal die Funktion "cmp" in Java umgeschrieben (ein bisschen sauberer):

Java

```
public int cmp(Channel a, Channel  b){
		int xOrder = 0;
		if (a.getOrder() == b.getOrder()){
			xOrder = (a.getId() < b.getId()) ? -1 : 1;
		} else {
			xOrder = (a.getOrder() < b.getOrder()) ? -1 : 1 ;
		}

		return xOrder;
	}
```

Dieser Code ist eine eigene Methode. Sie ist in der gleichen Klasse enthalten wo die Methode zum Liste erzeugen/channel erzeugen etc. ist.

Nun habe ich gelesen man soll Vectoren mit Comparable sortieren. Nun,... ich hab keine Ahnung wie ich das machen soll, so das ich die "Regeln" der oben genannten Methode "cmp" benutze.

getOrder() ist eine Methode die einen int zurück liefert. Das gleiche bei getId().


Wenn ich Comparable in meine Klasse "Channel" implementiere

```
public class Channel implements Comparable<Channel> {
```
dann muss ich ja eine neue Methode hinzufügen:

```
public int compareTo(Channel o) {
		// TODO Auto-generated method stub
		return 0;
	}
```

So, da ich mittlerweile keine Idee mehr habe wie ich das o.g. umsetzte .. brauche ich Hilfe und wende mich deshalb an euch. 
Hoffe es war verständlich geschrieben was ich möchte. Falls ich noch ein bisschen Code posten soll oder sonst Fragen dazu beantworten soll, nur her damit


----------



## Gast (15. Mai 2008)

mach die Methode static und für sie in compareTo aus
oder schreib den inhalt der cmp einfach ins compareTo.

dann kannst du mit Collections.sort den Vector sortieren


----------



## w00t (15. Mai 2008)

Daran habe ich auch gedacht, aber da fehlt mir irgendwie eins:

Wenn ich nun die Methode "cmp"in meine andere Methode (compareTo()) einfüge, was ist denn dann die Variable b? Ich habe doch nur die eine Klasse Channel "a", aber die Channel sind ja an und für sich unabhängig voneinander. Die kennen ja die anderen Channel gar nicht. 

Ich glaub ich hab nen riesigen Denkfehler bei dem ganzen Comparable zeug   

Kannst Du mir vielleicht ein Beispiel geben wie ich das  mit dem Collections.sort(cList) und dem Comparable mache? Steht total auf dem Schlauch.


----------



## ARadauer (15. Mai 2008)

```
public int compareTo(Channel o) { 
      // TODO Auto-generated method stub 
      return 0; 
   }
```
a wäre in diesem fall this
also das aktuelle objekt und b wäre das o

Comparable heißt Vergleichbar, ich bin das objekt und irgendwer gibt mir ein anders objekt o und sagt: vergleiche dich damit, compare


----------



## ARadauer (15. Mai 2008)

alernativ kannst du dir auch einen seperaten comperator machen. Also ich vergleiche nichts  mit mir sondern ich bin an und für sich ein Vergleicher und verleiche zwei Objekte.


```
public class Test implements Comparator<String> {	


	public int compare(String o1, String o2) {
	 //hier dein zeugs
		return 0;
	}
}
```
in diesem Fall gibst du dem sort von Collections zusätzlich eine Instanz des Comperators mit


----------



## w00t (15. Mai 2008)

(Das jetzt zu deinem 1. beitrag)

Also müsste in der Klasse Channel das hier stehen:


```
public int compareTo(Channel o) {
		int xOrder = 0;
		if (this.getOrder() == o.getOrder()){
			xOrder = (this.getId() < o.getId()) ? -1 : 1;
		} else {
			xOrder = (this.getOrder() < o.getOrder()) ? -1 : 1 ;
		}
		return xOrder;
	}
```


Und nachdem ich alles in die Liste eingefügt habe .. das hier:


```
// Liste erzeugen etc. pp.

Collections.sort(cList);
```


----------



## ARadauer (15. Mai 2008)

also wenn this id kleiner ist als o id dann -1 , ja das müsste passen.
und sie muss natürlich das Interface implementieren 

```
public class Channel  implements Comparable<Channel> {
```
damit Collections.sort(cList); weiß, dass es die Elemente sortieren kann


----------



## w00t (15. Mai 2008)

Ok, vielen Dank 
Scheint zu klappen. 

Nur hab ich gerade irgendwo ne Endlosschleife (liegt aber net am sortieren^^), da das ja nicht so performant ist, muss ich da mal suchen *lach*
//EDIT:
Schon scheiße wenn man nen i mit ner 1 austauscht .. dann kann die schleife ja nur endlos werden


----------

