# Array nach dem Alphabet sortieren



## Barbossa (28. Dez 2011)

Hallo Forum,

ich möchte ein Array mit Strings nach dem Alphabet sortieren. Ich kenne bereits einige sortieralgorithmen, jedoch nur für Zahlen und deswegen weiß ich nicht wie ich das ganze auf die Anfangsbuchstaben der Strings übertragen kann.

Ich möchte auch nicht die compareTo() Methode benutzen, sondern den Algorithmus selber implementieren.

Danke im voraus

lg Barbossa


----------



## Landei (28. Dez 2011)

Sortieralgorithmen funktionieren normalerweise(*) völlig unabhängig vom Datentyp oder der Vergleichsfunktion. Wenn du nicht [c]String.compareTo()[/c] verwenden willst, schreibe dir einen [c]Comparator<String>[/c]. Natürlich reicht es normalerweise nicht, nur den ersten Buchstaben zu vergleichen...

Dann kannst du dir eine Sortierfunktion, die für einen beliebigen [c]Comparator<T>[/c] funktioniert, schreiben, oder einfach [c]Arrays.sort(T[], Comparator<T>)[/c] verwenden.

(*) Ausnahme: BucketSort und ähnliche gehen von einer fest vorgegebenen Anzahl möglicher Werte aus.


----------



## Final_Striker (28. Dez 2011)

Du kannst auch direkt einzelne Zeichen vergleichen.


```
char z1 = 'a';
char z2 = 'b';

if(z1 < z2){
   do something
else{
   do something else
}
```

Die Methode 
	
	
	
	





```
indexOf
```
der Klasse String wird du auch noch brauchen.


----------



## Landei (28. Dez 2011)

Final_Striker hat gesagt.:


> Die Methode
> 
> 
> 
> ...



Eher [c]charAt[/c].


----------



## Final_Striker (28. Dez 2011)

Landei hat gesagt.:


> Eher [c]charAt[/c].



Ja, die meinte ich eigentlich. :-D


----------



## Barbossa (29. Dez 2011)

danke für die schnelle antwort.

ich wusste nicht, dass man zeichen einfach mit dem < operater vergleichen kann. 
Geht das auch mit worten? wird dann die länge des Wortes abgefragt oder wirklich die Alphabetische Reihenfolge?

Kannst du deinen Vorschlag nochmal näher erklären? Ich programmiere leider noch nicht so lange als dass ich das verstehen könnte.

Lg Barbossa


----------



## Helgon (29. Dez 2011)

Man vergleicht nicht die Zeichen selbst, sondern deren ASCII Wert, der ja eine Zahl ist und diese "glücklicherweise" alphabetisch/numerisch sortiert sind.

http://www.cdrummond.qc.ca/cegep/informat/Professeurs/Alain/images/ASCII1.GIF

Du kannst bei Worten bspw. mit 
	
	
	
	





```
substring(int beginIndex, int endIndex)
```
 das erste Zeichen abfragen und dann damit wie mit einzelnen Zeichen vorgehen.


----------



## Helgon (29. Dez 2011)

Nicht richtig aufgepasst, natürlich 
	
	
	
	





```
charAt(int index)
```
 in diesem Fall


----------



## Landei (29. Dez 2011)

Barbossa hat gesagt.:


> Geht das auch mit worten? wird dann die länge des Wortes abgefragt oder wirklich die Alphabetische Reihenfolge?



Etwas ausführlicher: Mit 
	
	
	
	





```
<
```
 u.s.w. können nur die primitiven Datentypen verglichen werden, also 
	
	
	
	





```
boolean
```
, 
	
	
	
	





```
byte
```
, 
	
	
	
	





```
short
```
, 
	
	
	
	





```
int
```
, 
	
	
	
	





```
long
```
, 
	
	
	
	





```
float
```
 und 
	
	
	
	





```
double
```
.

Für Objekte gibt es zwei "konkurrierende" Vergleichsverfahren: 

1) Der Typ 
	
	
	
	





```
T
```
 implementiert das Interface 
	
	
	
	





```
Comparable<T>
```
 mit der Methode 
	
	
	
	





```
compareTo(T t)
```
. Je nachdem ob der Rückgabewert kleiner, gleich oder größer 0 ist, ist das aktuelle Objekt kleiner, gleich oder größer als das übergebene, z.B. wäre 
	
	
	
	





```
"foo".compareTo("bar")
```
 größer als 0, weil 
	
	
	
	





```
"foo"
```
 "größer" als
	
	
	
	





```
"bar"
```
 ist. Wird dieses Interface implementiert, sagt man auch, der Typ habe eine "natürliche" Ordnung. Viele eingebaute Klassen unterstützen 
	
	
	
	





```
Comparable
```
, z.B. 
	
	
	
	





```
String
```
, 
	
	
	
	





```
Date
```
oder Unterklassen von 
	
	
	
	





```
Number
```
. 

Strings werden standardmäßig "alphabetisch" sortiert, genauer gesagt nach Unicode, was z.B. Probleme mit deutschen Umlauten nach sich zieht. Deshalb gibt es noch einen speziellen Mechanismus für "lokalisierte" Ordnungen über die Klasse 

```
Collator
```
.

2) Oft braucht man für ein und dieselbe Klasse unterschiedliche Sortiermodi (z.B. auf- und absteigend, eine Person nach Name oder Alter u.s.w.). Da eine Klasse nur eine "natürliche" Ordnung (also 
	
	
	
	





```
Comparable
```
-Implementierung) haben kann, kommt man so nicht weiter. Außerdem hat man manchmal Klassen, die selbst nicht 
	
	
	
	





```
Comparable
```
sind, aber trotzdem sortiert werden sollen. Die Lösung ist, ein separates "Vergleicher-Objekt" vom Typ 
	
	
	
	





```
Comparator<T>
```
 zu erstellen. Dieser 
	
	
	
	





```
Comparator
```
hat die Methode 
	
	
	
	





```
compare(T first, T second)
```
, die ähnlich wie 
	
	
	
	





```
compareTo
```
 funktioniert.

Oft hat man die Möglichkeit, sich für den gewünschten Mechanismus zu entscheiden (z.B. sortiert ein 
	
	
	
	





```
TreeSet
```
 ohne weitere Angaben nach der natürlichen Ordnung, man kann aber auch einen 
	
	
	
	





```
Comparator
```
angeben)


----------



## Barbossa (31. Dez 2011)

Ok zuallererst muss ich euch allen einmal danken für die schnelle Hilfe, besonders dir Landei.

Ich denke grob habe ich verstanden was passiert, jedoch kann ich das noch nicht genau so umsetzen.

Vielleicht wäre es besser wenn ich versuche mal genauer zu erklären was ich überhaupt vorhabe, denn nachdem ich nun weiterprogrammiert habe muss ich nun doch eine Liste alphabetisch sortieren und nicht ein array.

Im endeffekt habe ich Personen in einem sozialen Netzwerk, die alle gewisse Interessen haben. Diese Interessen haben je nachdem wie stark sich eine Person für etwas interessiert ein Gewicht. Diese Interessen und Gewichte sind nun eben in Listen gespeichert und wenn ich nun die Interessen zweier Personen vergleichen will, muss ich zuerst schauen ob beide die gleichen Interessen haben und falls nicht eben die Listen auffüllen und entsprechende Gewichtungen auf 0 setzen.
Soweit bin ich nun. Jetzt haben beide listen die gleichen Elemente, jedoch eben nicht sortiert. 

Wie kann erreichen, dass beide Listen jeweils das gleiche Element an gleicher Stelle haben? im endeffekt ist es eigentlich egal ob es alphabetisch ist oder nicht, es muss eben gleich sein, ich dachte mir nur alphabetisch liegt wohl am naheliegendsten.


----------



## new222 (1. Jan 2012)

> Etwas ausführlicher: Mit < u.s.w. können nur die primitiven Datentypen verglichen werden, also boolean , byte , short , int , long , float und double .



Also boolean kann man IN JAVA nur auf gleichheit[==] oder ungleichheit[!=] testen...das hab ich schon gelernt


----------



## Final_Striker (1. Jan 2012)

Barbossa hat gesagt.:


> Wie kann erreichen, dass beide Listen jeweils das gleiche Element an gleicher Stelle haben? im endeffekt ist es eigentlich egal ob es alphabetisch ist oder nicht, es muss eben gleich sein, ich dachte mir nur alphabetisch liegt wohl am naheliegendsten.



Warum läuft du nicht einfach über die Liste einer Person und überprüfst ob ihre Interessen in der Interessenliste der zweiten Person vorhanden sind und merkst dir die gleichen Interessen?


----------

