Stack Java на массивах

import java.util.Iterator;
 
public class Stack<T> implements Iterable<T> {
    private class Node {
        private T value;
        private Node next;
        
        public Node(T val, Node last) {
            value = val;
            next = last;
        }
        public T getValue() {
            return value;
        }
        public Node getNext() {
            return next;
        }
    }
    
    private Node top;
    
    private class StackIterator implements Iterator<T> {
 
        public boolean hasNext() {
            return ( top != null ) ;
        }
 
        public T next() {
            T ret = top.getValue();
            top = top.getNext();
            return ret;
        }
 
        public void remove() {
            
        }
        
    }
 
    public Iterator<T> iterator() {
        return new StackIterator();
    }
    
    void push(T value) {
        top = new Node(value, top);
    }
}

import java.util.Iterator;
 
public class StackTester {
    public static void main(String[] args) {
        Stack<Integer> intStack = new Stack<Integer>();
        intStack.push(1);
        intStack.push(2);
        intStack.push(3);
        
        Iterator<Integer> intIterator = intStack.iterator();
        while ( intIterator.hasNext() )
            System.out.println(intIterator.next().toString());
        
        Stack<String> strStack = new Stack<String>();
        strStack.push("any");
        strStack.push("many");
        strStack.push("money");
        strStack.push("more");
        
        Iterator<String> strIterator = strStack.iterator();
        while ( strIterator.hasNext() )
           System.out.println(strIterator.next());
        
        Stack<Person> persons = new Stack<Person>();
        persons.push(new Person("Сидоров", 43));
        persons.push(new Person("Петров", 45));
        persons.push(new Person("Иванов", 44));
        
        
        Iterator<Person> person = persons.iterator();
        while ( person.hasNext() )
            System.out.println(person.next());
    }
}

package easybudda.arraystack;
 
import java.util.Iterator;
 
public class ArrayStack<T> implements Iterable<T> {
    private Object[] array;
    private int capacity;
    private int top;
    
    @SuppressWarnings("serial")
    public static class StackIsFullException extends Exception {
        public StackIsFullException(String s) {
            super(s);
        }
    }
    
    @SuppressWarnings("serial")
    public static class StackIsEmptyException extends Exception {
        public StackIsEmptyException(String s) {
            super(s);
        }
    }
    
    public ArrayStack(int capacity) throws IllegalArgumentException {
        this.capacity = capacity;
        if ( capacity < 1 )
            throw new IllegalArgumentException();
        array = new Object [ capacity ];
        top = 0;
    }
    
    public boolean isEmpty() {
        return ( top == 0 );
    }
    
    public boolean isFull() {
        return ( top == capacity );
    }
    
    public void push(T value) throws StackIsFullException {
        if ( isFull() )
            throw new StackIsFullException("Satck is full! Value " + value + " rejected.");
        array[top++] = value;
    }
    
    @SuppressWarnings("unchecked")
    public T pop() throws StackIsEmptyException {
        if ( isEmpty() )
            throw new StackIsEmptyException("Stack is empty!");
        return (T)array[--top];
    }
 
    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
 
            @Override
            public boolean hasNext() {
                return ( ! isEmpty() );
            }
 
            @Override
            public T next() {
                try {
                    return pop();
                }
                catch ( StackIsEmptyException e ) {
                    return null;
                }
            }
 
            @Override
            public void remove() {
                
            }
            
        };
    }
}

package easybudda.arraystack;
 
import java.util.Iterator;
 
public class Test {
 
    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<Integer>(3);
        
        for ( int i = 0; i < 4; ++i ) {
            try { 
                stack.push(100 + i + 1);
            }
            catch ( ArrayStack.StackIsFullException e ) {
                System.out.println(e.getMessage());
            }
        }
        
        Iterator<Integer> it = stack.iterator();
        while ( it.hasNext() )
            System.out.println(String.valueOf(it.next()));
        
        try {
            int notExists = stack.pop();
            System.out.println(String.valueOf(notExists));
        }
        catch ( ArrayStack.StackIsEmptyException ee ) {
            System.out.println(ee.getMessage());
        }
    }
}