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

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

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.");
}

}

Expert Solution
trending now

Trending now

This is a popular solution!

steps

Step by step

Solved in 2 steps

Blurred answer
Similar questions
  • SEE MORE QUESTIONS
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education