# ArrayList sortieren.



## JonnieWalker (7. Apr 2010)

Hi Leute,

habe eine Frage:

Also Leute ich hab hier diese ArrayList mit der ist es mir Möglich 
etwas einzugeben und mir diese Liste wieder so ausgeben zu lassen.
Mit eingeben meine ich z.b alle Wörter die mehr Buchstaben als 4 haben.
Es funktioniert wunderbar.
Hier der Code:

```
public ArrayList<Words> getWords() {
        Words Datensatz;
        ResultSet daten;
        String eigAnzahl = null;

        try {
             Statement anweisung = v2.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                    ResultSet.CONCUR_READ_ONLY);
            eigAnzahl = FensterFilter.tfEingWorter.getText();
daten = anweisung.executeQuery("SELECT word from words where len(word)> "+eigAnzahl+"");
            while (daten.next()) {
                Datensatz = new Words(
                        daten.getString("word"));
                retWords.add(Datensatz);
            }
        } catch (Exception ex) {
        }
        return retWords;

    }
```

das Problem ist ich will die Datensätze aus der ArrayList oben nochmal durch betätigen meines
Buttons "Nach Anfangsbuchstaben sortieren" nochmal demendsprechend sortiert haben.
Sozusagen einmal oben nach Anzahl Buchstaben und jetzt nochmal nach Alphabet.

Hier die Methode die das machen soll:

```
public ArrayList<Words> getWords2(){ 
   
      Words Datensatz;
        ResultSet daten;

        try {
            Statement anweisung = v2.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                    ResultSet.CONCUR_READ_ONLY);
            daten = anweisung.executeQuery("SELECT wordID, word FROM words ORDER BY word ASC ");
            while (daten.next()) {
                Datensatz = new Words(
                        daten.getString("word"));

                retWords2.add(Datensatz);
            }
        } catch (Exception ex) {
        }
        return retWords2;
    }
```
Mir ist bewusst das dort einige veränderungen stattinden müßen.
Ich muss das i-wie hinbekommen das er die obere ArrayList nimmt und die sortiert
Ich hab viele Seiten durchgeschaut und nichts brauchbares gefunden.

Vielen Dank schon mal:toll:


----------



## nrg (7. Apr 2010)

In die Klasse Words comparable implementieren und die compareTo überschreiben oder einen comparator schreiben...

edit:

```
public class Words implements Comparable<Words> {
private String deinAttribut;
public String getDeinAttribut() {
return deinAttribut;
}
@Override
public int compareTo( Words o ) {
if ( this == 0 )
return 0;
else
return this.getDeinAttribut.compareTo( o.getDeinAttribut );
}


in deiner Methode:

return Collections.sort(retWords);
```

das ist jetzt einfach so in browser getippt (keine Garantie auf korrekte Syntax). dient nur als Beispiel

edit2: bzw eben eine Methode die einfach Collections.sort aufruft. Ein extra query deswegen auszuführen ist imho nicht Sinn der Sache und zu vermeiden...

frag mich bei deinem Code auch wo retWords initialisiert wird aber das ist denke ein anderes Thema. hoff mal ich hab dich überhaupt richtig verstanden...


----------



## AlexSpritze (7. Apr 2010)

Wenn du verschieden Sortierkriterien hast, wäre das Implementieren von mehreren Comparatoren besser:


```
public class WordLengthComparator implements Comparator<Word>{
    @Override
    public int compare( Word o1, Word o2 ) {
      return new Integer(o1.getWordLength()).compareTo(new Integer(o2.getWordLength()));
    }
}
```

Unter der Annahme, dass die Methode getWordLength() in der Klasse Word die Länge des Wortes als int zurückgibt.
Dementsprechend könntest du auch einen Comparator für die Sortiernung nach dem Alphabet schreiben oder dich auf die Sortierung der Klasse String verlassen oder den case-insensitiven Comparator in der String Klasse verlassen (String.CASE_INSENSITIVE_ORDER).


----------



## JonnieWalker (8. Apr 2010)

Danke das war sehr hilfreich sind zwar noch ien paar probleme aber die werd ich auch noch beheben
:lol:


----------



## Genesius (8. Apr 2010)

Vielleicht solltest du auch lieber SQL die sortierung übernehmen lassen ....is doch wesentlich einfacher als arraylist zu sortieren, insbesondere, wenn man spezielle sortierungmöglichkeiten braucht !!! oder seh ich das falsch?


----------



## JonnieWalker (8. Apr 2010)

Wie meinst du das?
also das ist die zweite methode.
die erste methode gibt mir daten aus die ich filtere.
die zweite methode soll mir diese gefilterten daten nochmal nach anfangsbuchstabe sortieren.

Methode 1Filter)

```
public ArrayList<Words> getWords() {
        Words Datensatz;
        ResultSet daten;
        String eigAnzahl = null;
        String eigBuchst = null;
        try {
             Statement anweisung = v2.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                    ResultSet.CONCUR_READ_ONLY);
            eigAnzahl = FensterFilter.tfEingWorter.getText();
            eigBuchst = FensterFilter.tfBuchstabe.getText();
            daten = anweisung.executeQuery("SELECT word FROM words WHERE len(word)> "+eigAnzahl+" AND word LIKE '" +eigBuchst+ "%'");
             
            while (daten.next()) {
                Datensatz = new Words(
                        daten.getString("word"));
                retWords.add(Datensatz);
            }
        } catch (Exception ex) {
        }
        return retWords;
    }
```

Methode 2Soll die ArrayList der ersten Methode nochmal nach Anfangsbuchstaben wie im sql statement sortieren):


```
public ArrayList<Words> getWords2(){

      Words Datensatz;
      ResultSet daten;

        try {
            Statement anweisung = v2.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                    ResultSet.CONCUR_READ_ONLY);
            daten = anweisung.executeQuery("SELECT wordID, word FROM words ORDER BY word ASC ");
            while (daten.next()) {
                Datensatz = new Words(
                        daten.getString("word"));

                [COLOR="Red"]retWords2.add(Datensatz);[/COLOR]
            }
        } catch (Exception ex) {
        }
       [COLOR="Red"] return retWords2;[/COLOR]
    }
```
wie soll as gehen hab auch den ersten vorschlag versucht aber der machts nicht so:noe:


----------



## Genesius (8. Apr 2010)

Chill doch einfach ma, du weisst nicht wie man lebt


----------



## Michael... (8. Apr 2010)

Wenn Du nur sortieren willst, was ist der Sinn der Datenbankabfrage in der zweiten Methode?

Möglichkeit 1: Du wendest in die gewünschte Sortierung direkt in DB Abfrage an.
Möglichkeit 2: Du verwendest wie weiter oben bereits erwähnt einen Comparator. Listen können mit Collections#sort(java.util.List) bzw. Collections#sort(java.util.List, java.util.Comparator) sortiert werden.


----------



## JonnieWalker (8. Apr 2010)

die zweite methode sollte eigendlich so sein das ich die gefilterten datensätze der ersten methode nehme und nochmal wie in der zweiten methode sortiere.


----------



## Michael... (8. Apr 2010)

keine Ahnung wie Deine Klasse Words aussieht.

Mal angenommen sie besitzt eine Methode 
	
	
	
	





```
public String getString()
```
 könnte man sie mit folgendem Comparator nach dem Rückgabewert der Methode sortieren.

```
ArrayList<Words> list = new ArrayList<Words>();
...
Collections.sort(list, new Comparator<String>() {
	public int compare(Words word1, Words word2) {
		return word1.getString().compareTo(word2.getString());
	}
});
```


----------



## JonnieWalker (8. Apr 2010)

meine Words-Klasse ist ziemlich klein gehalten:
das ist sie:


```
package meloft;

public class Words {
    private String word;

    public Words( String word){

        this.word = word;
    }

    @Override
    public String toString(){
        return  word;
    }
  }
```


----------



## Michael... (8. Apr 2010)

Dann musst Du halt toString() statt getString() im Comparator schreiben.


----------



## JonnieWalker (8. Apr 2010)

danke muss hier noch eben was machen und dann mach ich mal die sortierung!


----------

