LinkedList program unresponsive; possible null pointer error

Question

Alright, so I hate to ask for help on a problem so vague, but I'm working on a project right now that doesn't seem to be getting any compile-time errors, yet won't do what's asked of it. To sum it up simply, this project is a linked list(unordered list, to be specific) that functions as a text editor. It takes in a file as a command line argument, then stores every separate line of the document as a node in the list. Whether it's doing that for sure or not I don't know, but after that the program takes in specific commands(keyboard input) and edits or lists the text of the file as requested.

The problem is, I can't even tell if the file is being stored in the list or not because every time I give the command L for list, the program just 'skips' it and continues on as if nothing was asked of it. It may be that the file isn't being stored for whatever reason, or there may be an issue with the toString method of the unorderedList class.

The code for all of my classes is as follows:

public class LinearNode<T> {

    //Begin by declaring the basic node and its data
    private LinearNode<T> next;
    private T element;

    public LinearNode() {
        //The basic null constructor
        next = null;
        element = null;

    }

    public LinearNode(T elem)   {
        //The overloaded constructor to create a node
        next = null;
        element = elem;

    }

    public LinearNode<T> getNext()  {
        //Get the node reference
        return next;

    }

    public void setNext(LinearNode<T> node) {
        //Create or redirect a node reference
        next = node;

    }

    public T getElement()   {
        //Get the actual data stored in the node
        return element;

    }

    public void setElement(T elem)  {
        //Create or redirect the node's data
        element = elem;

    }

}

And for the lists

public abstract class LinkedList<T> implements ListADT<T>, UnorderedListADT<T> {

    protected int count;
    protected LinearNode<T> head, tail;
    protected int modCount;

    public LinkedList ()    {
        count = 0;
        head = null;
        tail = null;
        head = tail;
        head.setNext(tail);
        modCount = 0;
    }

    public T remove(T targetElement) throws EmptyCollectionException, ElementNotFoundException  {
        if(isEmpty())
            throw new EmptyCollectionException("LinkedList");

        boolean found = false;
        LinearNode<T> previous = null;
        LinearNode<T> current = head;

        while(current!=null&&!found)    {
            if(targetElement.equals(current.getElement()))  {
                found = true;
            }

            else    {
                previous = current;
                current = current.getNext();
            }

        }

        if(!found)
            throw new ElementNotFoundException("Linked List");

        if(size()==1)   {
            head = tail = null;
        }

        else if(current.equals(head))
            head = current.getNext();

        else if(current.equals(tail))   {
            tail = previous;
            tail.setNext(null);
        }

        else    {
            previous.setNext(current.getNext());
        }

        count--;
        modCount++;

        return current.getElement();
    }


}

import java.util.Iterator;

public class UnorderedList<T> extends LinkedList<T>{

    public UnorderedList()  {
        super();
    }

    public void addToFront(T element)   {
        if(head==null)  {
            head = new LinearNode<T>(element);
            if(tail==null)  {
                tail = head;
            }
            count++;
            modCount++;
        }
        else    {
            LinearNode<T> current = head;
            head.setElement(element);
            head.setNext(current);
            count++;
            modCount++;
        }
    }

    public void addToRear(T element)    {
        if(tail.getElement()==null) {
            tail.setElement(element);
            count++;
            modCount++;
        }
        else    {
            LinearNode<T> current = tail;
            tail = new LinearNode<T>(element);
            current.setNext(tail);
            count++;
            modCount++;
        }
    }

    public void addAfter(T element, T target)   {
        LinearNode<T> current = head;
        LinearNode<T> node = new LinearNode<T>(element);
        LinearNode<T> temp = null;
        while(!(current.getElement()==target))  {
            current = current.getNext();
        }
        if(!(current.getNext()==null))  {
            temp = current.getNext();
            //temp.setElement(current.getElement());
        }
        current.setNext(node);
        node.setNext(temp);
        count++;
        modCount++;
    }

    public T removeLast()   {
        T last = tail.getElement();
        tail = null;
        LinearNode<T> current = head;
        while(!(current.getNext()==null))   {
            current = current.getNext();
        }
        current = tail;
        count--;
        modCount++;
        return last;
    }

    public int size()   {
        return count;
    }

    public Iterator<T> iterator()   {
        Iterator<T> itr = this.iterator();
        return itr;
    }

    public boolean isEmpty()    {
        boolean result = false;
        if(head==null&&tail==null)  {
            result = true;
        }
        else
            result = false;
        return result;
    }

    public T first()    {
        return head.getElement();
    }

    public T last() {
        return tail.getElement();
    }

    public boolean contains(T elem) {
        boolean result = false;
        for(T element : this)   {
            if(element==elem)   {
                result = true;
                break;
            }
        }
        return result;
    }

    public T removeFirst()  {
        LinearNode<T> current = head;
        head = current.getNext();
        count--;
        modCount++;
        return current.getElement();
    }

    public String toString()    {
        LinearNode<T> current = head;
        String s = "";
        for(int countA=0;countA<count;count++)  {
            s += (countA+1)+"> "+current.getElement()+"\n";
            current = current.getNext();
        }
        return s;
    }

}

and for the main editor

import java.util.Scanner;
import java.util.Iterator;
import java.io.*;

public class myEditor {

    public static void saveToFile(String text, String filename) throws IOException{
        PrintWriter out = new PrintWriter(new File(filename));
        out.println(text);
        out.close();
    }

    public static void main(String args[])  {
        boolean quit = false;
        try {
            if(args.length!=1)  {
                throw new IllegalArgumentException();
            }

            String filename = args[0];
            Scanner input = new Scanner(new File(filename));
            //Add exception
            UnorderedList<String> list = new UnorderedList<String>();
            while(input.hasNextLine())  {
                if(list.head==null) {
                    list.addToFront(input.nextLine());
                }
                list.addToRear(input.nextLine());
            }

            System.out.println(">");

            do  {
                Scanner command = new Scanner(System.in);
                String comm = command.next();
                String[] comm1 = comm.split(" ");
                if(comm1.length==1) {
                    if(comm1[0].equalsIgnoreCase("I"))  {
                        System.out.println("Type a line of text >");
                        comm = command.next();
                        list.addToRear(comm);
                    }
                    else if(comm1[0].equalsIgnoreCase("L")) {
                        System.out.print(list.toString());
                    }

                    else if(comm1[0].equalsIgnoreCase("E")) {
                        saveToFile(list.toString(), filename);
                        quit = true;
                        break;
                    }
                }
                else    {
                    if(comm1[0].equalsIgnoreCase("I"))  {
                        int linNum = Integer.parseInt(comm1[1]);
                        Iterator<String> itr = list.iterator();
                        String current = "";
                        for(int count=0;count<linNum;count++)   {
                            current = itr.next();
                        }
                        list.addAfter(comm, current);
                    }

                    else if(comm1[0].equalsIgnoreCase("D")) {
                        int linNum = Integer.parseInt(comm1[1]);
                        if(linNum<=list.count&&linNum>0)    {
                            Iterator<String> itr = list.iterator();
                            String current = "";
                            for(int count=0;count<linNum;count++)   {
                                current = itr.next();
                            }
                            list.remove(current);
                        }
                    }
                }

            }
            while(!quit);
        }
        catch(IllegalArgumentException e)   {
            System.err.print(e.getMessage());
        }
        catch(FileNotFoundException e)  {
            System.err.print(e.getMessage());
        }

        catch(IOException e)    {
            System.err.print(e.getMessage());
        }

    }
}

There's a few other classes and some interfaces as well, but for the issue I'm experiencing, I don't think they're that relevant.

Does anyone see what might be happening here, or what I might have written wrong to cause my program to ignore the command?

Answer 1

Look at your LinkedList constructor

    head = null;
    tail = null;
    head = tail;
    head.setNext(tail);

head is null yet you call its setNext method, it should throw an NPE.