What is wrong with my java code in Eclipse?

I have 4 different classes and it won't give an output. the problems are in the scorestest with the print function and in scores with the nodes. Please help.

ScoresTest:

public class ScoresTest 
{
    public static void main(String[] args) 
    {       
        // create 
        SLinkedList<GameEntry> highScores = new SLinkedList<GameEntry>();  
        GameEntry entry;

        // create entries.
        Scores rank = new Scores();     
        entry = new GameEntry("John", 351);     
        highScores = rank.add(entry, highScores);
        entry = new GameEntry("Steven", 198);
        highScores = rank.add(entry, highScores); 
        entry = new GameEntry("Jeremy", 834);
        highScores = rank.add(entry, highScores); 
        entry = new GameEntry("Jake",520);
        highScores = rank.add(entry, highScores); 
        entry = new GameEntry("Alex", 588);
        highScores = rank.add(entry, highScores); 
        entry = new GameEntry("Jack", 777);
        highScores = rank.add(entry,highScores); 

        System.out.println("The Original High Scores");
        rank.print(highScores);

        entry = new GameEntry("Wesley", 895);
        highScores = rank.add(entry, highScores);
        System.out.println("Scores after adding Wesley");
        rank.print(highScores);
    }
}

Scores:

import Project1.SLinkedList.Node;

public class Scores 
{
    //add function
    public SLinkedList<GameEntry> add(GameEntry rank, SLinkedList<GameEntry> scores)
    {
        Node<GameEntry> currentNode = scores.getFirst();
        Node<GameEntry> nextNode = null;
        Node<GameEntry> newNode = new Node<GameEntry>();
        newNode.setElement(rank);

        if(scores.getSize() == 0)
        {
            scores.addFirst(newNode);
        }
        else
        {
            while(currentNode != null)
            {               
                nextNode = currentNode.getNext();
                if(nextNode == null)
                {
                    scores.addLast(newNode);
                }
                else
                {
                    scores.addAfter(currentNode, newNode);
                    break;
                }               
                currentNode = currentNode.getNext();
            }
        }
        return scores;
    }
}

SLinkedList:

public class SLinkedList<V> implements Cloneable 
{
    public static class Node<V> 
    {
        // instance variables
        private V element;
        private Node<V> next;

        // methods, constructor first
        public Node () 
        {
            this (null, null);      // call the constructor with two args
        }  // end no argument constructor
        public Node (V element, Node<V> next) 
        {
            this.element = element;
            this.next = next;
        }  // end constructor with arguments

        // set/get methods
        public V getElement () 
        { 
            return element; 
        }
        public Node<V> getNext () 
        { 
            return next; 
        }
        public void setElement (V element) 
        { 
            this.element = element; 
        }
        public void setNext (Node<V> next) 
        { 
            this.next = next; 
        }

    } // End of nested node class


    // instance variables.  
    protected Node<V> head, tail;
    protected long size;

    // Create empty constructor
    public SLinkedList () {
        head = null;
        tail = null;
        size = 0;
    } // end constructor 

    // Add Fist method to add node to list. 
    public void addFirst (Node<V> node) {
        // set the tail only if this is the very first node
        if (tail == null)
            tail = node;
        node.setNext (head);    //refer to head
        head = node;            

        // adjust size.
        size++;
    }  // end addFirst method.

    // Add new node after current node. Checks to see if at tail also.
    public void addAfter (Node<V>currentNode, Node<V>newNode) {
        if (currentNode == tail)
            tail = newNode;
        newNode.setNext (currentNode.getNext ());
        currentNode.setNext (newNode);

        // adjust size.
        size++;
    }  // end addAfter method.


    // Add new node after the tail. 

    public void addLast (Node<V> node) {
        node.setNext (null);
        tail.setNext (node);
        tail = node;
        size++;     
    }  // end addLast method



    // Removes first node.  
    public Node<V> removeFirst () {
        if (head == null)
            System.err.println("Error:  Attempt to remove from an empty list");

        // save the one to return.
        Node<V> temp = head;

        head = head.getNext ();
        temp.setNext(null);
        size--;

        return temp;

    }  // end method removeFirst

    // remove the node at the end of the list.  
    public Node<V> removeLast () {
        // // declare local variables/objects
        Node<V> nodeBefore;
        Node<V> nodeToRemove;

        // make sure we have something to remove
        if (size == 0)
            System.err.println("Error:  Attempt to remove fron an empty list");

        // traverse through the list, getting a reference to the node before
        // the trailer.  Since there is no previous reference.
        nodeBefore = getFirst ();

        // potential error  ??  See an analysis and drawing that indicates the number of iterations
        // 9/21/10.  size - 2 to account for the head and tail nodes.  We want to refer to the one            before the
        // tail.
        for (int count = 0; count < size - 2; count++)
            nodeBefore = nodeBefore.getNext ();

        // save the last node
        nodeToRemove = tail;

        // now, do the pointer manipulation
        nodeBefore.setNext (null);
        tail = nodeBefore;
        size--;

        return nodeToRemove;

    }  // end method removeLast

    // Remove known node from list. Traverses through the list.
    public void remove (Node<V> nodeToRemove) {

        // declare local variables/references
        Node<V> nodeBefore, currentNode;

        // is there something to remove.
        if (size == 0)
            System.err.println("Error:  Attempt to remove fron an empty list");

        // Start at beginning of list.
        currentNode = getFirst ();
        if (currentNode == nodeToRemove)
            removeFirst ();
        currentNode = getLast ();
        if (currentNode == nodeToRemove)
            removeLast ();

        // Check last two nodes.
        if (size - 2 > 0) {
            nodeBefore = getFirst ();
            currentNode = getFirst ().getNext ();
            for (int count = 0; count < size - 2; count++) {
                if (currentNode == nodeToRemove) {

                    // remove current node
                    nodeBefore.setNext (currentNode.getNext ());
                    size--;
                    break;
                }  // end if node found

                //  references
                nodeBefore = currentNode;
                currentNode = currentNode.getNext ();
            }  // end loop to process elements
        }  // end if size - 2 > 0

    }  // end method remove

    // Get methods 
    public Node<V> getFirst () { return head; }
    public Node<V> getLast () { return tail; }  
    public long getSize () { return size; }
}

GameEntry:

public class GameEntry  
{
    private String name;        // name of the person earning this score
    private int score;          // the score value

    // Constructor
    public GameEntry(String n, int s) 
    {
        name = n;
        score = s;
    }

    // Get methods.

    public String getName() { return name; }
    public int getScore() { return score; }

    // Return string representation.
    public String toString() 
    {
        return "(" + name + ", " + score + ")";
    } 
}// end class.

I don't see a print function in your Scores class. That may be why you are not getting anything to print out. What exactly are you trying to do?

This article has been dead for over six months. Start a new discussion instead.