Get LinkedList-Instanz in Java

Question

Ich bin neu in Java. Ich habe versucht, einige Tests zu machen, während ich selbst die Sprache lehre. Jetzt bin ich auf einer verketteten Listenimplementierung. Ich habe den Code von Testproben online veröffentlicht. Es gibt zwei Dateien, LinkedList und LinkedListIterator. Ich verstehe die Umsetzung gut. Ich möchte jedoch Methoden zu der LinkedList-Klasse hinzufügen. Eine Methode (getString()) wird verwendet, um eine Verkettung aller Stringvariablen in der Linkedlist anzuzeigen. Die zweite Methode getSize() wird verwendet, um die Größe der Liste anzuzeigen. Ich habe Probleme, die aktuelle Instanz der Linkedlist zu bekommen, damit ich die Strings und die Größe iterieren kann. Kann jemand bitte helfen? Hilfe wird sehr geschätzt. Die beiden Dateien sind wie folgt:

import java.util.NoSuchElementException; 

public class LinkedList 
{ 
    //nested class to represent a node 
    private class Node 
    { 
      public Object data; 
      public Node next; 
    } 

    //only instance variable that points to the first node. 
    private Node first; 

    // Constructs an empty linked list. 
    public LinkedList() 
    { 
     first = null; 
    } 


    // Returns the first element in the linked list. 
    public Object getFirst() 
    { 
     if (first == null) 
     { 
     NoSuchElementException ex 
      = new NoSuchElementException(); 
     throw ex; 
     } 
     else 
     return first.data; 
    } 

    // Removes the first element in the linked list. 
    public Object removeFirst() 
    { 
     if (first == null) 
     { 
     NoSuchElementException ex = new NoSuchElementException(); 
     throw ex; 
     } 
     else 
     { 
     Object element = first.data; 
     first = first.next; //change the reference since it's removed. 
     return element; 
     } 
    } 

    // Adds an element to the front of the linked list. 
    public void addFirst(Object element) 
    { 
     //create a new node 
     Node newNode = new Node(); 
     newNode.data = element; 
     newNode.next = first; 
     //change the first reference to the new node. 
     first = newNode; 
    } 

    // Returns an iterator for iterating through this list. 
    public ListIterator listIterator() 
    { 
     return new LinkedListIterator(); 
    } 


    public String toString(){ 

     } 

     public int getSize(){ 
      return this.size(); 
     } 

    //nested class to define its iterator 
    private class LinkedListIterator implements ListIterator 
    { 
     private Node position; //current position 
     private Node previous; //it is used for remove() method 

     // Constructs an iterator that points to the front 
     // of the linked list. 

     public LinkedListIterator() 
     { 
     position = null; 
     previous = null; 
     } 

    // Tests if there is an element after the iterator position. 
    public boolean hasNext() 
     { 
     if (position == null) //not traversed yet 
      { 
      if (first != null) 
       return true; 
      else 
       return false; 
      } 
     else 
      { 
       if (position.next != null) 
       return true; 
       else 
       return false; 
      } 
     } 

     // Moves the iterator past the next element, and returns 
     // the traversed element's data. 
     public Object next() 
     { 
     if (!hasNext()) 
      { 
      NoSuchElementException ex = new NoSuchElementException(); 
      throw ex; 
      } 
     else 
      { 
      previous = position; // Remember for remove 

      if (position == null) 
       position = first; 
      else 
       position = position.next; 

      return position.data; 
      } 
     } 

     // Adds an element before the iterator position 
     // and moves the iterator past the inserted element. 
     public void add(Object element) 
     { 
     if (position == null) //never traversed yet 
     { 
      addFirst(element); 
      position = first; 
     } 
     else 
     { 
      //making a new node to add 
      Node newNode = new Node(); 
      newNode.data = element; 
      newNode.next = position.next; 
      //change the link to insert the new node 
      position.next = newNode; 
      //move the position forward to the new node 
      position = newNode; 
     } 
     //this means that we cannot call remove() right after add() 
     previous = position; 
     } 

     // Removes the last traversed element. This method may 
     // only be called after a call to the next() method. 
     public void remove() 
     { 
     if (previous == position) //not after next() is called 
      { 
      IllegalStateException ex = new IllegalStateException(); 
      throw ex; 
      } 
     else 
      { 
      if (position == first) 
      { 
       removeFirst(); 
      } 
      else 
      { 
       previous.next = position.next; //removing 
      } 
      //stepping back 
      //this also means that remove() cannot be called twice in a row. 
      position = previous; 
     } 
     } 

     // Sets the last traversed element to a different value. 
     public void set(Object element) 
     { 
     if (position == null) 
      { 
      NoSuchElementException ex = new NoSuchElementException(); 
      throw ex; 
      } 
     else 
      position.data = element; 
     } 

    } //end of LinkedListIterator class 
} 

LinkedListIterator Klasse:

public interface ListIterator 
{ 
    //Move Moves the iterator past the next element. 
    Object next(); 

    // Tests if there is an element after the iterator position. 
    boolean hasNext(); 

    // Adds an element before the iterator position 
    // and moves the iterator past the inserted element. 
    void add(Object element); 


    // Removes the last traversed element. This method may 
    // only be called after a call to the next() method. 
    void remove(); 

    // Sets the last traversed element to a different value. 
    void set(Object element); 
} 

Fehler, wenn ich die implmentation von getSize versuchen():

Exception in thread "main" java.lang.StackOverflowError 
    at assignment10.LinkedList.size(LinkedList.java:84) 
    at assignment10.LinkedList.size(LinkedList.java:84) 
    at assignment10.LinkedList.size(LinkedList.java:84) 
    at assignment10.LinkedList.size(LinkedList.java:84) 

Answer 1

Die getSize() könnte

public int getSize(){ 
    int size = 0; 
    ListIterator iterator = listIterator(); 
    while(iterator.hasNext()) { 
     iterator.next(); 
     size++; 
    } 

    return size; 
} 

Aber es ist nicht effizient, jedes Mal über die Liste zu iterieren, um seine Größe zu kennen. Die bessere Lösung besteht darin, die Größe als Klassenvariable zu speichern und in Methodenänderungslisten zu erhöhen oder zu verringern.

Die Idee der toString() Methode ist die gleiche, über die Liste durchlaufen und jedes Element mit dem String Ergebnis anhängen

public String toString(){ 
    StringBuilder sb = new StringBuilder(); 
    ListIterator iterator = listIterator(); 
    while(iterator.hasNext()) { 
     sb.append(String.valueOf(iterator.next())).append(","); 
    } 

    return sb.toString; 
}