Question

What is wrong with my code, when I pass in 4 It will not run, without the 4 it will run, but throw and error. I am getting the error  

required: no arguments
found: int
reason: actual and formal argument lists differ in length
where T is a type-variable:
T extends Object declared in class LinkedDropOutStack

public class Help {
/**
* Program entry point for drop-out stack testing.
* @param args Argument list.
*/
public static void main(String[] args) {
LinkedDropOutStack<Integer> stack = new LinkedDropOutStack<Integer>(4);
  
System.out.println("DROP-OUT STACK TESTING");
  
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);   
stack.push(5);   
  
System.out.println("The size of the stack is: " + stack.size());
if(!stack.isEmpty())
System.out.println("The stack contains:\n" + stack.toString());
  
stack.pop();
stack.push(7);
stack.push(8);
  
System.out.println("The size of the stack is: " + stack.size());
if(!stack.isEmpty())
System.out.println("The stack contains:\n" + stack.toString());
}
  
public static class LinkedDropOutStack<T> implements DropoutStackADT<T> {   
//TODO: Implement me.
private final int DEFAULT_CAPACITY = 8;

// refers to the item in the array being indexed

private int cIndex;
private int count;//counts the number in the stack
private T[] stack;

public void DropOutStackADT() {
cIndex = 0;
count = 0;
stack = (T[]) (new Object[DEFAULT_CAPACITY]);
}

public void DropOutStackADT(int initialCapacity) {
cIndex = 0;
count = 0;
stack = (T[]) (new Object[initialCapacity]);
}

public T peek() throws EmptyCollectionException {
if (isEmpty())
throw new EmptyCollectionException("Drop-out Stack");
return stack[(cIndex + stack.length - 1)%stack.length];
}

public T pop() throws EmptyCollectionException {
if (isEmpty())
throw new EmptyCollectionException("Drop-out Stack");
cIndex = (cIndex + stack.length - 1)%stack.length;
T result = stack[cIndex];
stack[cIndex] = null;
count--;
return result;
}
  

public void push(T element)throws EmptyCollectionException {
cIndex = cIndex % stack.length;
stack[cIndex] = element;
cIndex++;
if (count != stack.length)
count++;
}

public int size() {
return count;
}
  

public boolean isEmpty() {
return size() == 0;
}
  

public String toString() {
String str = "";
int temp = cIndex;
int length = size();
while(length != 0) {
str += stack[(temp + stack.length - 1)%stack.length] + " ";
temp--;
length--;
}

return str;
}
}
}

Answer 1

//project.java

public class project {

public static void main(String[] args) {
LinkedDropOutStack<Integer> stack = new LinkedDropOutStack<Integer>(4);
System.out.println("DROP-OUT STACK TESTING");
  
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);   
stack.push(5);   
  
System.out.println("The size of the stack is: " + stack.size());
if(!stack.isEmpty())
System.out.println("The stack contains:\n" + stack.toString());
  
stack.pop();
stack.push(7);
stack.push(8);
  
System.out.println("The size of the stack is: " + stack.size());
if(!stack.isEmpty())
System.out.println("The stack contains:\n" + stack.toString());
}
  
public static class LinkedDropOutStack<T> implements StackADT<T> {  
   private int top = 0;
private T[] stack;
  
   @SuppressWarnings("unchecked")
           public LinkedDropOutStack(int initialCapacity) {
stack = (T[])(new Object[initialCapacity]);
   }

   public void push(T element) {
if (size() == stack.length) {
for (int i = 0; i < stack.length - 1; i++) {
   stack[i] = stack[i + 1];
}
       stack[stack.length - 1] = element;
} else {
   stack[top] = element;
   top++;
}
}
  
   public T pop() throws EmptyCollectionException {
if (isEmpty())
throw new EmptyCollectionException("stack");
  
top--;
T result = stack[top];
stack[top] = null;
  
return result;
}

   public T peek() throws EmptyCollectionException {
if (isEmpty())
throw new EmptyCollectionException("stack");
  
return stack[top-1];
}

   public boolean isEmpty() {
return (top == 0);
}

   public int size() {
   return top;
}
  
   public String toString() {
   String result = "";
               for (int i = top-1; i >= 0; i--)
       result += stack[i] + "\n";
return result;
}
}
}

=======================================================================

//StackADT.java

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);
  
/**
* 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();
}

===================================================================

//EmptyCollectionException.java

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

===================================================================

sample output: