Create a generic type java interface StackADTwith the following methods: a.public void push(T element);//Push an element at the top of a stack

Book: Java Software Structures

Author: John Lewis; Joe Chase

Javascript

1. Create a generic type java interface StackADT<T>with the following methods:

a.public void push(T element);//Push an element at the top of a stack

b.public T pop();//Remove and return an element from the top of a stack

c.public T peek();//return the top element without removing it

d.public booleanisEmpty();//Return True if a stack is emptye.public int size();//Return the number of elements in a stack

f.public String toString();//Print all the elements of a stack

2. Define ArrayStack<T>class which will implementStackADT<T>interface

3. Use your ArrayStack<T>class to compute a postfix expression, for instance, 3 4 * will yield12;3 4 6 + *will yield 30 etc.

During computing a postfix expression:

a.While you perform a push operation, if the stack is full, generate an exception

b.While you perform a pop operation, if the stack is empty, generate an exception

c.If two operands are not available on the stack for an operator, generate a message, “Postfix expression is invalid”.

d.If more than one operand is available, while no operator is left, generate a message, “Postfix expression is invalid”.

So far I have:

package com.company;

public interface StackADT<T>
{
/**
* Adds the specified element to the top of this stack.
* @param element element to be pushed onto the stack
*/
public void push(T element)
throws java.lang.IllegalArgumentException;

/**
* Removes and returns the top element from this stack.
* @return the element removed from the stack
*/
public T pop();

/**
* Returns without removing the top element of this stack.
* @return the element on top of the stack
*/
public T peek();

/**
* Returns true if this stack contains no elements.
* @return true if the stack is empty
*/
public boolean isEmpty();
/**
* Returns the number of elements in this stack.
* @return the number of elements in the stack
*/
public int size();

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

package com.company;
import java.util.Arrays;

public class ArrayStack<T> implements StackADT<T>
{
private final static int DEFAULT_CAPACITY = 100;

private int top;
private T[] stack;

/**
* Creates an empty stack using the default capacity.
*/
public ArrayStack()
{
this(DEFAULT_CAPACITY);
}

/**
* Creates an empty stack using the specified capacity.
* @param initialCapacity the initial size of the array
*/
public ArrayStack(int initialCapacity)
{
top = 0;
stack = (T[])(new Object[initialCapacity]);
}
/**
* Adds the specified element to the top of this stack, expanding
* the capacity of the array if necessary.
* @param element generic element to be pushed onto stack
*/
public void push(T element)
{
if (size() == stack.length)
expandCapacity();

stack[top] = element;
top++;
}

@Override
public boolean isEmpty()
{
while (top==0)
return true;
return false;
}

@Override
public int size() {
return 0;
}

/**
* Creates a new array to store the contents of this stack with
* twice the capacity of the old one.
*/
private void expandCapacity()
{
stack = Arrays.copyOf(stack, stack.length * 2);
}

/**
* Removes the element at the top of this stack and returns a
* reference to it.
* @return element removed from top of stack
* @throws EmptyCollectionException if stack is empty
*/

public T pop() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("stack");

top--;
T result = stack[top];
stack[top] = null;

return result;
}
/**
* Returns a reference to the element at the top of this stack.
* The element is not removed from the stack.
* @return element on top of stack
* @throws EmptyCollectionException if stack is empty
*/
public T peek() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("stack");

return stack[top-1];
}
}

package com.company;

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

}