How to insert an object to a linkedlist ADT?

[Andrew Parker]

Hi,
Here are 3 sources code from a data structure book:

public class LinkedList
{
/**
* Construct the list
*/
public LinkedList( )
{
header = new ListNode( null );
}
/**
* Test if the list is logically empty.
* @return true if empty, false otherwise.
*/
public boolean isEmpty( )
{
return header.next == null;
}
/**
* Make the list logically empty.
*/
public void makeEmpty( )
{
header.next = null;
}

/**
* Return an iterator representing the header node.
*/
public LinkedListItr zeroth( )
{
return new LinkedListItr( header );
}
/**
* Return an iterator representing the first node in the list.
* This operation is valid for empty lists.
*/
public LinkedListItr first( )
{
return new LinkedListItr( header.next );
}
/**
* Insert after p.
* @param x the item to insert.
* @param p the position prior to the newly inserted item.
*/
public void insert( Object x, LinkedListItr p )
{
if( p != null && p.current != null )
p.current.next = new ListNode( x, p.current.next );
}
/**
* Return iterator corresponding to the first node containing an item.
* @param x the item to search for.
* @return an iterator; iterator isPastEnd if item is not found.
*/
public LinkedListItr find( Object x )
{
/* 1*/ ListNode itr = header.next;
/* 2*/ while( itr != null && !itr.element.equals( x ) )
/* 3*/ itr = itr.next;
/* 4*/ return new LinkedListItr( itr );
}
/**
* Return iterator prior to the first node containing an item.
* @param x the item to search for.
* @return appropriate iterator if the item is found. Otherwise, the
* iterator corresponding to the last element in the list is returned.
*/
public LinkedListItr findPrevious( Object x )
{
/* 1*/ ListNode itr = header;
/* 2*/ while( itr.next != null && !itr.next.element.equals( x ) )
/* 3*/ itr = itr.next;
/* 4*/ return new LinkedListItr( itr );
}
/**
* Remove the first occurrence of an item.
* @param x the item to remove.
*/
public void remove( Object x )
{
LinkedListItr p = findPrevious( x );
if( p.current.next != null )
p.current.next = p.current.next.next; // Bypass deleted node
}
// Simple print method
public static void printList( LinkedList theList )
{
if( theList.isEmpty( ) )
System.out.print( "Empty list" );
else
{
LinkedListItr itr = theList.first( );
for( ; !itr.isPastEnd( ); itr.advance( ) )
System.out.print( itr.retrieve( ) + " " );
}
System.out.println( );
}
private ListNode header;

public static void main( String [ ] args )
{
LinkedList theList = new LinkedList( );
LinkedListItr theItr;
int i;
theItr = theList.zeroth( );
printList( theList );
for( i = 0; i < 10; i++ )
{
theList.insert( new MyInteger( i ), theItr );
printList( theList );
theItr.advance( );
}
for( i = 0; i < 10; i += 2 )
theList.remove( new MyInteger( i ) );
for( i = 0; i < 10; i++ )
if( ( i % 2 == 0 ) != ( theList.find( new MyInteger( i ) ).isPastEnd( ) ) )
System.out.println( "Find fails!" );
System.out.println( "Finished deletions" );
printList( theList );
}
}

public class LinkedListItr
{
/**
* Construct the list iterator
* @param theNode any node in the linked list.
*/
LinkedListItr( ListNode theNode )
{
current = theNode;
}
/**
* Test if the current position is past the end of the list.
* @return true if the current position is null.
*/
public boolean isPastEnd( )
{
return current == null;
}
/**
* Return the item stored in the current position.
* @return the stored item or null if the current position
* is not in the list.
*/
public Object retrieve( )
{
return isPastEnd( ) ? null : current.element;
}
/**
* Advance the current position to the next node in the list.
* If the current position is null, then do nothing.
*/
public void advance( )
{
if( !isPastEnd( ) )
current = current.next;
}
ListNode current; // Current position
}

class ListNode
{
// Constructors
ListNode( Object theElement )
{
this( theElement, null );
}
ListNode( Object theElement, ListNode n )
{
element = theElement;
next = n;
}
// Friendly data; accessible by other package routines
Object element;
ListNode next;
}

For the public void insert( Object x, LinkedListItr p )
{
if( p != null && p.current != null )
p.current.next = new ListNode( x, p.current.next );
}
It requires me to pass Object x and LinkedListItr p.
But, in the LinkedListItr class, the constructor requires the ListNode object:
LinkedListItr( ListNode theNode )
{
current = theNode;
}
However, the ListNode object takes Object theElement and ListNode n as parameters:
ListNode( Object theElement, ListNode n )
{
element = theElement;
next = n;
}
Now, I have a String array [100]. How can I insert those 100 objects one by one in the linked list?
I tried the following iteration code:
for( i = 0; i < 100; i++ ){
theList.insert(array[i], theItr ); //*** This has problem!!
printList( theList );
theItr.advance( );
}
It throws a NullPointerException. How can I fix it?
Thanks for help

[Andrew Parker]

sorry, i found the bug. I forgot to new the LinkedList object.