Question

I need to implement a stack array but the top of the stack has to be Initialize as the index of the last location in the array.

   //Array implementation of stacks.
   import java.util.Arrays;
  
   public class ArrayStack implements Stack {
       //Declare a class constant called DEFAULT_STACK_SIZE with the value 10.
  
       private static final int DEFAULT_STACK_SIZE = 10;
  
       /* Declare two instance variables:
           1. An integer called topOfStackIndex
           2. A reference variable of type array of objects.
       */
      
       private int topOfStackIndex;
       private Object[] stack;
      
       /* Write the one parameter constructor.
       The parameter indicates the size of the stack
       (i.e. the size of the array that represents that stack.)
       Be sure to create the array and initialize each element to null.
       Initialize the top of stack to be the index of the last location in the array.
       */
          
       public ArrayStack(int size) {
           this.topOfStackIndex = (size - 1);
          
           this.stack = new Object[size];
          
           for(int i = 0; i < size - 1; i++) {
               this.stack[i] = null;
           }
       }
  
       /* Write the default (no parameter) constructor.
       Initialize the instance variables by invoking the one parameter constructor
       you just completed. Set the size of the stack to DEFAULT_STACK_SIZE.
       */
      
       public ArrayStack() {
           this(DEFAULT_STACK_SIZE);
}
  
       /* Write the method to implement the push operation.
       Be sure to first check to see if the stack is full.
       If the stack is full invoke the method expandCapacity to 'grow' the stack.
       */
      
       public boolean isFull(){
           return topOfStackIndex == this.stack.length;
          
       }
      
       public void push(Object data) {
           if (isFull()) {
               expandCapacity();
           }
           else {
               ++topOfStackIndex;
               stack[topOfStackIndex] = data;
           }
       }
  
       /* Write the method to implement peek operation.
       It should throw an EmptyCollectionException if the stack is empty.
       A stub method is provided for you.
       A stub method is a method that is a temporary substitute for yet
       to be developed code.
       The header is correct. The body has no funcitonality except that
       it will satisfy the compiler.
       */

       public Object peek() throws EmptyCollectionException {
           if(!isEmpty()) {
               return stack[topOfStackIndex];
           }
           else {
               throw new EmptyCollectionException ("The stack is empty");
           }
       }

       /* Write the pop operation.
       Like the peek operation, pop should throw an EmptyCollectionException if the stack is empty.
       Be sure to set the position from where the element was removed to null.
       Again, a stub method is provide for you.
       */
      
       public Object pop() throws EmptyCollectionException {
           if(!isEmpty()) {
               this.stack[topOfStackIndex] = null;
               topOfStackIndex++;
               Object result = this.stack[topOfStackIndex];
               return result;
           }
           else {
               throw new EmptyCollectionException ("The stack is empty");
           }
       }

       /* Write the method isEmpty.
       It returns true if the stack is empty and false otherwise.
       */
     
       public boolean isEmpty() {
           return topOfStackIndex == -1;
       }

       /* Write the method size.
       It returns an integer representing the number of items on the stack.
       */

       public int size() {
           int count = 0;
           for(int i = 0; i < stack.length - 1; i++) {
               if(stack[i] != null) {
                   count++;
               }
           }
           return count;
       }

       //This method has been completed for you.
       @Override
       public String toString() {
           return(this.toString());
       }
  
       /* This method is called from the push method when the stack is full.
       It should keep the current stack contents and double the size of the stack.
       Hint: Look at the methods in the Java Arrays class to help you here.
       */
      
       public void expandCapacity() {
           //Object[] temp = new Object[stack.length * 2];
           Object[] temp;
           temp = Arrays.copyOf(stack, (stack.length * 2));
           stack = temp;
       }

       /* This method is used for testing purposes.
       It is complete. Do not modify this method.
       */
      
       public int whatIsTopOfStack() {
           return topOfStackIndex;
       }
   }

Answer 1

Code

import java.util.Arrays;

public class ArrayStack implements Stack {

private static final int DEFAULT_STACK_SIZE = 10;

private int topOfStackIndex;
private Object[] stack;

public ArrayStack(int size) {
this.topOfStackIndex = (size - 1);

this.stack = new Object[size];

for(int i = 0; i < size - 1; i++) {
this.stack[i] = null;
}
}
public ArrayStack() {
this(DEFAULT_STACK_SIZE);
}
public boolean isFull(){
return topOfStackIndex == this.stack.length;

}

public void push(Object data) {
if (isFull()) {
expandCapacity();
}
else {
++topOfStackIndex;
stack[topOfStackIndex] = data;
}
}

public Object peek() throws EmptyCollectionException {
if(!isEmpty()) {
return stack[topOfStackIndex];
}
else {
throw new EmptyCollectionException ();
}
}

public Object pop() throws EmptyCollectionException {
if(!isEmpty()) {
this.stack[topOfStackIndex] = null;
topOfStackIndex++;
Object result = this.stack[topOfStackIndex];
return result;
}
else {
throw new EmptyCollectionException ();
}
}

public boolean isEmpty() {
return topOfStackIndex == -1;
}

public int size() {
int count = 0;
for(int i = 0; i < stack.length - 1; i++) {
if(stack[i] != null) {
count++;
}
}
return count;
}

@Override
public String toString() {
return(this.toString());
}

public void expandCapacity() {
  
Object[] temp;
temp = Arrays.copyOf(stack, (stack.length * 2));
stack = temp;
}

public int whatIsTopOfStack() {
return topOfStackIndex;
}
}

//Add Stack class

//Create class EmptyCollectionException (Opens the new class wizard to create the type.)

//Package: (default package)
//public class EmptyCollectionException extends Exception {
//}