Question

ArrayStack.java This class represents a Stack implementation using an array as the underlying data structure. This class must implement the StackADT and work with the generic type (T). Note: the top index must start at -1 which is different than the versions you saw in lecture/lab. You will need to ensure the methods work with this altered format. The class must have the following private variables: • top (int) • stack (T array) • DEFAULT_CAPACITY (final int) with a value of 20 The class must have the following methods (all public unless otherwise stated): ArrayStack (constructor) – no parameters required in this first constructor. Initialize the top to -1 and the stack array using the final int variable as the array's capacity. ArrayStack (second constructor) - same as the first constructor described above, except that this one takes in an int parameter for the initial capacity rather than using the default capacity.

In Java. What would the methods of this class look like?

StackADT.java

public interface StackADT<T>
{
/** Adds one element to the top of this stack.
* @param element element to be pushed onto stack
*/
public void push (T element);
  
/** Removes and returns the top element from this stack.
* @return T element removed from the top of the stack
*/
public T pop();

/** Returns without removing the top element of this stack.
* @return T element on top of the stack
*/
public T peek();
  
/** Returns true if this stack contains no elements.
* @return boolean whether or not this stack is empty
*/
public boolean isEmpty();

/** Returns the number of elements in this stack.
* @return int number of elements in this stack
*/
public int size();

/** Returns a string representation of this stack.
* @return String representation of this stack
*/
public String toString();
}

EmptyCollectionsException.java

public class EmptyCollectionException extends RuntimeException
{
/**
* Sets up this exception with an appropriate message.
* @param collection String representing the name of the collection
*/
public EmptyCollectionException (String collection)
{
super ("The " + collection + " is empty.");
}
}

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. If not, PLEASE let me know before you rate, I’ll help you fix whatever issues. Thanks

//ArrayStack.java

public class ArrayStack<T> implements StackADT<T> {

      // private fields

      private T[] stack;

      private int top;// index of top of stack

      private static final int DEFAULT_CAPACITY = 20;

      // default constructor

      public ArrayStack() {

            // calling other constructor, passing default capacity

            this(DEFAULT_CAPACITY);

      }

      // constructor taking an initial capacity to initialize stack array, and

      // sets top to -1

      public ArrayStack(int capacity) {

            stack = (T[]) new Object[capacity];

            top = -1;

      }

      @Override

      public void push(T element) {

            // checking if stack is full

            if (top + 1 == stack.length)

                  expandCapacity(); // expanding capacity

            // incrementing top and then adding element at new top index

            stack[++top] = element;

      }

      // helper method to expand capacity by 20

      private void expandCapacity() {

            // creating a new array, copying items from old array, replacing old

            // array with new

            T[] newArray = (T[]) new Object[stack.length + 20];

            for (int i = 0; i < stack.length; i++)

                  newArray[i] = stack[i];

            stack = newArray;

      }

      @Override

      public T pop() {

            if (isEmpty()) {

                  // stack is empty

                  throw new EmptyCollectionException("Stack");

            }

            // otherwise returning value at top index and then decrementing top

            return stack[top--];

      }

      @Override

      public T peek() {

            if (isEmpty()) {

                  // stack is empty

                  throw new EmptyCollectionException("Stack");

            }

            // otherwise returning value at top index

            return stack[top];

      }

      @Override

      public boolean isEmpty() {

            return top == -1;

      }

      @Override

      public int size() {

            return top + 1; // count of elements

      }

      public int getTop() {

            return top; // top index

      }

      public int getlength() {

            return stack.length; // current capacity of the stack

      }

      @Override

      public String toString() {

            if (isEmpty()) {

                  // empty

                  return "The stack is empty";

            }

            String str = "STACK: ";

            // appending data of each value from top to bottom into str and

            // returning it

            for (int i = top; i >= 0; i--) {

                  str += stack[i];

                  // appending a ", " if there are more elements

                  if (i > 0) {

                        str += ", ";

                  }

            }

            return str + "."; // ading "." at the end and returning

      }

      // main method for testing. remove if not needed

      public static void main(String[] args) {

            // creating an ArrayStack

            ArrayStack<Integer> stk = new ArrayStack<Integer>();

            // adding numbers from 1 to 5

            for (int i = 1; i <= 5; i++) {

                  stk.push(i);

                  // displaying stack after each push

                  System.out.println(stk);

            }

            // looping until stk is empty

            while (!stk.isEmpty()) {

                  // popping top element and displaying updated stack

                  stk.pop();

                  System.out.println(stk);

            }

      }

}

/*OUTPUT*/

STACK: 1.

STACK: 2, 1.

STACK: 3, 2, 1.

STACK: 4, 3, 2, 1.

STACK: 5, 4, 3, 2, 1.

STACK: 4, 3, 2, 1.

STACK: 3, 2, 1.

STACK: 2, 1.

STACK: 1.

The stack is empty