Override toString in StackClass
<p>I have a program that implements a print queue. I have a StackClass that finds stackjob and stackcycle, but when I try to print these values, I get weird results, like hashtags. I know that I need to override <code>toString()</code>, but I can't get my code to compile when I add in the extra code.</p>

<p>I can't add the code inside my StackClass, because stackjob and stackcycle do not exist there. They exist in the PrintQueue file, which is my main method file. However, I cannot add the code within the main method because I get this error: PrintQ.java:10: ';' expected public String toString() { ^ and I can't add the code outside of the main method because I get: cannot find symbol error for both stackjob and stackcycle. Am I missing something?</p>

<p>I did the same in my Cycle class for jobNumber and cycleNumber and it works perfectly:</p>

<pre><code>@Override
public String toString() 
{
    StringBuilder sb = new StringBuilder();
    sb.append(jobNumber + " ");
    sb.append(cycleNumber);
    return sb.toString();
}
</code></pre>

<p>Below, stackjob and stackcycle are the values I need to override toString for.. any advice?</p>

<pre><code>StackClass&lt;Integer&gt; stackjob   = new StackClass();
StackClass&lt;Integer&gt; stackcycle = new StackClass();
</code></pre>

<p>Here is my StackClass</p>

<pre><code>       public class StackClass&lt;T&gt; implements StackADT&lt;T&gt;
       {
       private int maxStackSize;  //variable to store the
                           //maximum stack size
       private int stackTop;      //variable to point to
                           //the top of the stack
        private T[] list;  //array of reference variables
   //Create an array of the size 100 to implement the stack.
   //Postcondition: The variable list contains the base
   //               address of the array, stackTop = 0,
   //               and maxStackSize = 100.
  public StackClass()
  {
     maxStackSize = 100;
     stackTop = 0;         //set stackTop to 0
     list = (T[]) new Object[maxStackSize]; //create the array
  }//end default constructor

   //Constructor with a parameter
   //Create an array of the size stackSize to implement the
   //stack.
   //Postcondition: The variable list contains the base
   //               address of the array, stackTop = 0,
   //               and maxStackSize = stackSize.
  public StackClass(int stackSize)
  {
     if (stackSize &lt;= 0)
     {
        System.err.println("The size of the array to "
                         + "implement the stack must be "
                         + "positive.");
        System.err.println("Creating an array of the size 100.");

        maxStackSize = 100;
     }
     else
        maxStackSize = stackSize; //set the stack size to
                                  //the value specified by
                                  //the parameter stackSize
     stackTop = 0;    //set stackTop to 0
     list = (T[]) new Object[maxStackSize]; //create the array
  }//end constructor

   //Method to initialize the stack to an empty state.
   //Postcondition: stackTop = 0
  public void initializeStack()
  {
     for (int i = 0; i &lt; stackTop; i++)
        list[i] = null;

     stackTop = 0;
  }//end initializeStack

   //Method to determine whether the stack is empty.
   //Postcondition: Returns true if the stack is empty;
   //               otherwise, returns false.
  public boolean isEmptyStack()
  {
     return (stackTop == 0);
  }//end isEmptyStack

   //Method to determine whether the stack is full.
   //Postcondition: Returns true if the stack is full;
   //               otherwise, returns false.
  public boolean isFullStack()
  {
     return (stackTop == maxStackSize);
  }//end isFullStack

   //Method to add newItem to the stack.
   //Precondition: The stack exists and is not full.
   //Postcondition: The stack is changed and newItem
   //               is added to the top of stack.
   //               If the stack is full, the method
   //               throws StackOverflowException
  public void push(T newItem) throws StackOverflowException
  {
     if (isFullStack())
        throw new StackOverflowException();

     list[stackTop] = newItem; //add newItem at the
                              //top of the stack
     stackTop++;               //increment stackTop
  }//end push

   //Method to return a reference to the top element of
   //the stack.
   //Precondition: The stack exists and is not empty.
   //Postcondition: If the stack is empty, the method
   //               throws StackUnderflowException;
   //               otherwise, a reference to the top
   //               element of the stack is returned.
  public T peek() throws StackUnderflowException
  {
     if (isEmptyStack())
        throw new StackUnderflowException();

     return (T) list[stackTop - 1];
  }//end peek

   //Method to remove the top element of the stack.
   //Precondition: The stack exists and is not empty.
   //Postcondition: The stack is changed and the top
   //               element is removed from the stack.
   //               If the stack is empty, the method
   //               throws StackUnderflowException
  public void pop() throws StackUnderflowException
  {
     if (isEmptyStack())
        throw new StackUnderflowException();

     stackTop--;       //decrement stackTop
     list[stackTop] = null;
  }//end pop
</code></pre>

<p>}</p>

<p>And here is my PrintQ :</p>

<pre><code>             import java.io.*;
               import java.util.*;

            public class PrintQ {


  public static void main(String args[]) throws FileNotFoundException {

     String job1;

     int firstComma;
     int secondComma;

     QueueClass&lt;Cycle&gt; list= new QueueClass(100);
     QueueClass&lt;Integer&gt; cyclelist= new QueueClass(100);
     Cycle currentcycle= new Cycle();
     Cycle priorityCycle= new Cycle();
     Cycle Scycle= new Cycle();

     try{

        FileInputStream fstream = new FileInputStream("C:\\Users\\Whitney\\Desktop\\QueueIn.txt");
        DataInputStream in = new DataInputStream(fstream);
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String strLine;
        job1=br.readLine();
        while ((strLine = br.readLine()) != null)   {
           switch(job1.charAt(0)) {

              case 'q': 
                 {
                    System.out.println("loop q");
                    firstComma=job1.indexOf(',');
                    secondComma=job1.lastIndexOf(',');
                    currentcycle.jobNumber=Integer.parseInt(job1.substring(firstComma+1,secondComma));
                    currentcycle.cycleNumber=Integer.parseInt(job1.substring(secondComma+1));
                    cyclelist.addQueue(currentcycle.cycleNumber);
                    list.addQueue(currentcycle);

                    while(currentcycle.cycleNumber &gt; 0)
                    {

                       System.out.println(currentcycle.jobNumber + " "  + currentcycle.cycleNumber);
                       currentcycle.cycleNumber--;
                    }
                    //list.print();
                    break;
                 }

              case 'p': 
                 {    System.out.println("loop priority");                
                    firstComma=job1.indexOf(',');
                    secondComma=job1.lastIndexOf(',');
                    priorityCycle.jobNumber=Integer.parseInt(job1.substring(firstComma+1,secondComma));
                    priorityCycle.cycleNumber=Integer.parseInt(job1.substring(secondComma+1));
                    cyclelist.addQueue(priorityCycle.cycleNumber);
                    list.priorityinsert(priorityCycle);
                    while(priorityCycle.cycleNumber &gt; 0)
                    {
                       System.out.println(priorityCycle.jobNumber + " "  + priorityCycle.cycleNumber);
                       priorityCycle.cycleNumber--;

                    }
                    System.out.println(cyclelist);                     
                    //list.print();

                    break;
                 }

              case 's': 
                 {System.out.println("loop s");
                    firstComma=job1.indexOf(',');
                    Scycle.cycleNumber=Integer.parseInt(job1.substring(firstComma+1));
                    cyclelist.addQueue(Scycle.cycleNumber);                       
                    list.addQueue(Scycle);
                    while(Scycle.cycleNumber &gt; 0)
                    {
                       System.out.println(Scycle.jobNumber + " "  + Scycle.cycleNumber);
                       Scycle.cycleNumber--;

                    }


                    break;
                 }

              case 'h': 
                 {
                    System.out.println("loop halt");
                    StackClass&lt;Integer&gt; stackjob= new StackClass();
                    StackClass&lt;Integer&gt; stackcycle= new StackClass();



                    job1=(String) br.readLine();
                    //list.print();

                    System.out.println(stackjob.toString() +" " + stackcycle.toString());


                    while((strLine = br.readLine()) != null){

                       switch(job1.charAt(0)) {

                          case 'q':
                             {

                                firstComma=job1.indexOf(',');
                                secondComma=job1.lastIndexOf(',');
                                currentcycle.jobNumber=Integer.parseInt(job1.substring(firstComma+1,secondComma));
                                currentcycle.cycleNumber=Integer.parseInt(job1.substring(secondComma+1));
                                stackjob.push(currentcycle.jobNumber);
                                stackcycle.push(currentcycle.cycleNumber);
                                System.out.println("hi");
                                System.out.println(currentcycle.jobNumber + " "  + currentcycle.cycleNumber);
                                //list.print();
                                break;
                             }
                          case 'p':
                             {

                                firstComma=job1.indexOf(',');
                                secondComma=job1.lastIndexOf(',');
                                priorityCycle.jobNumber=Integer.parseInt(job1.substring(firstComma+1,secondComma));
                                priorityCycle.cycleNumber=Integer.parseInt(job1.substring(secondComma+1));
                                stackjob.push(priorityCycle.jobNumber);
                                stackcycle.push(priorityCycle.cycleNumber);
                                System.out.println(priorityCycle.jobNumber-- + " "  + priorityCycle.cycleNumber--);
                                break;
                             }

                          case 's':
                             {
                                firstComma=job1.indexOf(',');
                                secondComma=job1.lastIndexOf(',');
                                Scycle.cycleNumber=Integer.parseInt(job1.substring(secondComma+1));
                                stackjob.push(0);
                                stackcycle.push(Scycle.cycleNumber);
                                System.out.println(Scycle.jobNumber + " " + Scycle.cycleNumber); 
                                break;
                             }

                          case 'h': 
                             {
                                System.out.println("Halt - " + list);
                                continue;
                             }

                       }
                       job1=(String) br.readLine();

                    }   
                    //System.out.println();

                    while((stackjob.isEmptyStack()==false) || (stackcycle.isEmptyStack()==false)) 
                    { 
                       int printjob;
                       int printcycle;
                       Object peek;

                       printjob=stackjob.peek();
                       printcycle=stackcycle.peek();
                       stackcycle.pop();
                       stackjob.pop(); 
                       System.out.println("Job Number: "+printjob+" "+"Cycles Remaining: "+printcycle);
                    } 


                    continue;
                 }           
           }
           job1=br.readLine();
        }
        in.close();
     }
        catch (Exception e){//Catch exception if any
           System.err.println("Error: " + e.getMessage());
        }


     Cycle whilecurrent= new Cycle();

     while(list.isEmptyQueue()==false) 
     {
        whilecurrent=list.front();
        int whilecurrentcycle= cyclelist.front();
        //list.print();
        //System.out.println();

        //while(whilecurrentcycle != 0)
        //{
           //System.out.println();//"loop "+whilecurrentcycle--);  
        //}
        //System.out.println();

        //System.out.println(whilecurrent);

        cyclelist.deleteQueue();
        list.deleteQueue();   
     }  

     list.print();

  }
</code></pre>

<p>}</p>
