Double Linked List sotieren

[phreeak]

Guten Tag,

Ich muss fürs Studium im OOP Praktika ne Double Linked List erstellen. Soweit klappt alles

hier mal der code bisher:

public class DoListString {
  //Referenz der liste auf das erste Element 
    private Node first = null;
    private Node last = null;
    

      
     /**
     * Erstellt ein Knoten-Objekt und fügt es am Anfang der Liste ein.
     * @param string "Item" was in die Liste eingetragen werden soll.
     */
    public void addFirst(String string) {
        //wenn es schon ein Listenelemente gibt, wird das einfügen an die
        //Klasse Node übergeben
        if(this.first != null) {

            this.first = this.first.addNodeFirst(string);
            
        }
        //Wenn die Liste leer ist, wird ein neuer Knoten erzeugt
        else {
            this.first = this.last = new Node(string);
        }
    }//ende addFirst
    
    public void addLast(String string) {
        //wenn es schon ein Listenelemente gibt, wird das einfügen an die
        //Klasse Node übergeben
        if(this.first != null) {
          last.addNodeLast(string);
        }
        else {
            this.last = this.first = new Node(string);
        }
    }//ende addLast
    
    public String toString() {
     return first.toString();
    }
    
        
     /**
     * Methode zum durchsuchen, gibt false oder true zurück
     * @return string Wonach gesucht werden soll
     * @return true/false
     */
    public boolean find(String string) {
    boolean info;
    info = first.find(string);
    return info;
    }
}

public class Node {
// Referenz auf den Nachfolger
private Node next;
//Da es sich um eine doppelt verkette Liste handelt, wird eine Referenz auf den 
//vorgänger benötigt
private Node prev;
//item repräsentiert hier die eigentliche Nutzlast des Knotens
private String item = "";

public Node(String _item) {
    this.item = _item;
    this.next = null;
    this.prev = null;
} //ende Konstruktor

     /**
     * Methode die das Inhalt zurück gibt.
     * @return item
     */
     public String getItem() {
        return item;
    }

     public Node addNodeFirst(String string) {
         Node newNode = new Node(string);
         //der Zeiger muss auf das erste element zeigen damit nix gelöscht wird 
         //Zeiger zeigt auf den vorgänger
         this.prev = newNode;
         newNode.next = this;
         return newNode;
         
     }//ende addNodeFirst
     
     public void addNodeLast(String string) {
         Node hilfsNode = this;
        
         while (hilfsNode.next != null) {
         hilfsNode = hilfsNode.next;
         
     }
         hilfsNode.next = new Node(string);
         hilfsNode.prev = hilfsNode;
         
     }//ende addNodeLast
     
    public String toString() {
        //Hilfvariable die auf den aktuellen Node zeigt
        Node helpVar = this;
        String stringInfo = "";
        
        //While durchläuft solange bis kein weiteren Knoten
        while (helpVar != null) {
            stringInfo +=helpVar.getItem() + " | ";
            //geht einen Knoten weiter
            helpVar = helpVar.next;
        }
        return stringInfo;
    } //ende toString
   
    
   private Node findNode(String _s){
    //referenz auf das nöchste Object/Knoten        
    Node aktNode = this;
    // solange aktNode nicht null ist, aso solang einen Nachfolger hat
    while(aktNode != null){
        // wenn der gesuchte String mit der Nutzlast von aktNode über-
        // einstimmt, ist der gesuchte Knoten gefunden und wir zurück
        // gegeben
        if(aktNode.item.equals(_s)){
        return aktNode;
        }
    // Referenz auf den Nachfolger von aktNode setzen
    aktNode = aktNode.next;
    }
    // wenn nichts gefunden wird, wird null zurück gegeben.
    return null;
}

           /**
     * Methode zum durchsuchen, gibt false oder true zurück
     * @return string Wonach gesucht werden soll
     * @return true/false
     */
    public boolean find(String string) {
       //Hilfvariable die auf den aktuellen Node zeigt
        // die vorher in findNote(string) gesucht wird
        Node helpVar = findNode(string); 
         //falls Node existiert 
        if (helpVar != null) {
            //wenn eine Übereinstimmung ist wird true zurück gegeben
            if(helpVar.getItem().equals(string)) 
                return true;
            
        } //ende der schleife
        return false;
    }//ende find
    
    

} //ende klasse

Wie gesagt soweit funktioniert alles. kann an erster stelle was hinzufügen und an letzter. Finden geht auch.

nun steht aber:

Einfügen eines Strings so, dass die Liste die Strings natürlich sortiert.
Finden Sie für den Vergleich von Strings eine passende Methode in der API-Dokumentation.

und entweder ich hab in der Vorlesung geschlafen oder es kam nicht dran und ich habe überhaupt ka, wie man das macht. Mit Comparator, Compareable?

Collections.sort(neu);

geht auch nicht in der main

public class main {
  public static void main(String[] args) {
      DoListString neu = new DoListString();
      neu.addFirst("7");
      neu.addFirst("6");
      System.out.println(neu.toString());

      Collections.sort(neu);
  }   
}

z.B
kennt Collections nicht..
hat einer irgendwelche Tips um welche Methode es sich handelt in der API-Doku?

 

[Akeshihiro]

Um's mal kurz zu machen: Deine Liste muss das Interface java.util.List implementieren, damit Collections Instanzen davon sortieren kann.