# Lineare Liste selber programmieren



## Zar von Domarus (23. Mrz 2015)

Wir sollen im Unterricht eine Lineare Liste zu Lernzwecken programmieren, leider tritt bei mir immer das Problem einer NullPointerExeption auf.
Das Programm ist simpel aufgebaut. Zwei Klassen, die eine Node, die dazu dient das Objekt aufzunehmen, welches in der Liste gespeichert werden soll, und verweist auf den nächsten Knoten, die andere LinList, welche die Liste organisiert. First, Last, Current speichern Nodes um Anfang und Ende, sowie das aktuell zu bearbeitende Element der Liste zu kennen.
Des Weiteren existiert in der LinList ein Dummy, er existiert in jeder Liste und wird mit dem Konstruktor der Klasse LinList erzeugt. Er stellt immer das letzte Element der Liste dar und besitzt keinen Inhalt und verweist auf das Element vor ihm, sollte kein Element in der Liste sein, auf sich selbst.

Main:

```
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package lineareliste;

/**
 *
 * @author Zar von Domarus
 */
public class main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        LinList L = new LinList();
        
        for( int i = 100; i < 1000; i += 100){
            Integer x = i;
            L.append(x);
        }
        
        L.toFirst();
        
        for(int y = 0; y < 10; y++)
        {
            Object help = L.getObject();
            System.out.println(help);
            L.toNext();
        }
                
    }
    
}
```

Die Klasse LinList:

```
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package lineareliste;

/**
 *
 * @author Zar von Domarus
 */
public class LinList {
    private Node first, current, last, dumm;
    private int count;
    private Object help;
    
    /**
     * Constructor of LinList
     * no parameters
     */
    public void LinList(){
        dumm = new Node(null, null);
        dumm.setNext(dumm);
        first = new Node(null, dumm);
        first.setNext(dumm);
        current = new Node(null, dumm);
        current.setNext(dumm);
        last = new Node(null, dumm);
        last.setNext(dumm);
        
    }

    public void toNext(){
        current = current.getNext();
    }

    public void toFirst(){
        current = first;
    }

    private void toLast(){
        current = last;
    }

    public Object getObject(){
        return current.getContent();
    }

    public void setObject(Object o){
        current.setContent(o);
    }

    public void append(Object o){
        count++;
        
        Node n = new Node(o, dumm);
        
        if(first.getNext() == last.getNext()){ 
            dumm.setNext(n);
            current.setNext(n);
            n.setNext(dumm);
        }else{
            current = dumm.getNext();
            n.setNext(dumm);
            current.setNext(n);
            dumm.setNext(n);
        }
    }
}
```

Und die Klasse Node:

```
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package lineareliste;

/**
 *
 * @author Zar von Domarus
 */
public class Node {
    private Node next;
    private Object o;
    
    /**
    * Construct the new node
    * @param cont the object which comes into the new node
    * @param n reference to next node
    */
    Node(Object cont, Node n){
        next = n;
        o = cont;
    }
    
    /**
    * Setter next Node
    * @param n the new next node
    */
    public void setNext(Node n){
        next = n;
    }
    
    /**
    * Getter next Node
    * @return the next node
    */
    public Node getNext(){
        return next;
    }
    
    /**
    * Getter Content, the object in the node
    * @return the object respectively the content
    */
    public Object getContent(){
        return o;
    }
    
    /**
    * Setter Content, the object in the node
    * @param cont new content respectively object
    */
    public void setContent(Object cont){
        o = cont;
    }
    
    
}
```

Das Problem des NullPointers tritt in der LinList in der Methode append auf (Zeile 58). 
Die Zeile"if(first.getNext() == last.getNext()){" des Codes liefert die Exeption zurück, aber ich weis nicht wie ich das Problem lösen kann, weil ich bis jetzt glaube, dass nicht auf eine mit null belegte Stelle zugegriffen wird, aber dies ja offensichtlich doch anders ist.

Ich wäre dankbar um Ratschläge.
PS: Mein Englisch in den Kommentaren ist schlecht


----------



## Flown (24. Mrz 2015)

Deine Variablen werden nie initialisiert, denn dein "Konstruktor" hat ein void (also ist es eine Methode).


```
public void LinList(){
  ... 
}
```
sollte so aussehen:

```
public LinList() {
  ...
}
```

Dann sollte auch nichts mehr null sein.


----------



## Zar von Domarus (24. Mrz 2015)

Danke, mit noch einer kleinen Änderung funktioniert es jetzt, vielen Dank.


----------

