Hi Guys,

So I'm trying to fix a small problem with my code. It does everything correctly but when reading from the file I want to not count the space between words. For instance if the line is Hello world the output should be:
11: Hello world
but instead it prints
12: Hello world

import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

public class MarshallTracie6<T> extends AbstractCollection<T> {
	/* Creates a new LinkedList called list. */
	LinkedList<T> list = new LinkedList<T>();

	/* add method calls on LinkedList's add method and overrides it. */
	public boolean add(T value) {
		list.add(value);
		return true;
	}

	/* Constructor for MarshallTracie6 */
	public MarshallTracie6() {

	}

	/* Creates a new ListIterator */
	public ListIterator<T> iterator() {
		ListIterator<T> iterator = new ListIterator<T>(list);
		return iterator;
	}

	/* The size method, call on the getSize method and returns the size. */
	public int size() {
		return list.getSize();

	}

	/* Creates a String printCollection and returns it. */
	public String toString() {
		String printer = "";
		ListIterator<T> myIterator = iterator();

		while (myIterator.hasNext()) {
			String currentLine = myIterator.next() + "";
			printer += currentLine.length() + ": " + currentLine + "\n";
		}
		return printer;
	}

	public static void main(String[] args) {
		/* Creates a new instance or MarshallTracie6 called myCollection */
		MarshallTracie6<String> myCollection = new MarshallTracie6<String>();

		if (args.length == 1) {
			try {
				// open the file for reading 
				File file = new File(args[0]);
				Scanner scan = new Scanner(file);

				 //Reads the lines off the file 
				while (scan.hasNextLine()) {
					if (scan.hasNextLine()) {
						String line = scan.nextLine();
						myCollection.add(line);
					}

				}
				// Prints out the collection.
				System.out.println ("The Collection :");
				System.out.println(myCollection);

				// Catches and handles the FileNotFoundException 
			} catch (FileNotFoundException e) {
				System.out.println("Error:  File does not exist!");
				System.exit(0);
			}
		} else {
			System.out.println("Expected one file name as a parameter,found : "
					+ args.length);
		}
		
		// myCollection.add("Foo");
		// myCollection.add("Bar");
		// myCollection.add("What?");
		// System.out.print(myCollection);

	}
}

/* The Generic node class */
class Node<T> {
	/*
	 * two fields, the first to store the item itself, the second is a pointer
	 * to the next node in the linked list. If there is no next node, the
	 * pointer is null.
	 */
	private T item;
	private Node<T> nextNode;

	/*
	 * constructor:
	 * 
	 * @param value, the value for the node
	 * 
	 * @param next, the next node in the linked list
	 */
	public Node(T value, Node<T> next) {
		item = value;
		nextNode = next;
	}

	/* Accessor methods */
	public T getValue() {
		return item;
	}

	public Node<T> getNext() {
		return nextNode;
	}

	/* mutator methods */
	public void setNext(Node<T> newNext) {
		nextNode = newNext;
	}

	public void setValue(T value) {
		item = value;
	}
}

/*
 * The LinkedList class;
 */
class LinkedList<T> {
	/*
	 * only need to store a single pointer to the node at the head of the list.
	 * The pointer is null if the list is empty. Also record the size of the
	 * list.
	 */
	protected Node<T> head;
	/* invariant: size is the number of nodes in the list pointed to by head */
	protected int size;

	// Method to return the size
	public int size() {
		return size;
	}

	/* no-arguments default constructor creates an empty list */
	public LinkedList() {
		head = null; // start with an empty list
	}

	/*
	 * @param value to add to the end of the list
	 */
	public void add(T value) {
		head = addAtEnd(head, value);
			size++;
	}

	// Returns the size
	public int getSize() {
		return size;
	}

	/*
	 * @param node of the list to which the value should be added
	 * 
	 * @param value to add to the end of the list
	 */
	private Node<T> addAtEnd(Node<T> node, T value) {
		if (node == null) { // special case
			return new Node<T>(value, null);
		} else if (node.getNext() == null) { // other special case
			node.setNext(new Node<T>(value, null));
		} else {
			addAtEnd(node.getNext(), value);
		}
		return node;
	}

	/*
	 * @param position of item to be removed
	 * 
	 * @throws BadItemCountException if this is not a valid position position is
	 * 1-based, so position = 1 removes the head
	 */
	public void remove(int position) {
		if (position == 1) {
			head = head.getNext();
		} else {
			Node<T> node = head;
			for (int i = 2; i < position; i++) {
				node = node.getNext();
			}
			// set this node's "next" pointer to refer to the
			// node that is after the next
			node.setNext(node.getNext().getNext());
		}
	}

	/*
	 * convert the list to a printable string
	 * 
	 * @return a string representing the stack
	 */
	public String toString() {
		return toString(head);
	}

	private String toString(Node<T> node) {
		if (node == null) {
			return "";
		} else {
			return node.getValue() + "\n" + toString(node.getNext());
		}
	}
}

class ListIterator<T> extends LinkedList<T> implements Iterator<T> {
	/*
	 * a single field to store the first node, or null.
	 */
	private Node<T> nextNode;

	public ListIterator(LinkedList<T> list) {
		nextNode = list.head; // head is protected, so accessible to subclass
	}

	/*
	 * can at least one more value that can be accessed with this iterator?
	 * 
	 * @return whether there is another node
	 */
	public boolean hasNext() {
		return (nextNode != null);
	}

	/*
	 * @return the next value
	 * 
	 * @throws NoSuchElementException if there is no such value
	 */
	public T next() {
		if (hasNext()) {
			T value = nextNode.getValue();
			nextNode = nextNode.getNext();
			return value;
		} else {
			throw new NoSuchElementException("NodeIterator");
		}
	}

	/*
	 * @throws UnsupportedOperationException, meaning remove is not supported
	 */
	public void remove() {
		throw new UnsupportedOperationException("NodeIterator");
	}

}
This question has already been answered. Start a new discussion instead.