java如何用数组来模拟栈的先进后出

import java.util.Collection;   
import java.util.NoSuchElementException;   
  
public class ArrayStack<E> {   
       
    private int initalSize = 5;   
       
    private Object[] stack;   
       
    private int head;   
       
    private int tail;   
       
    public ArrayStack() {   
           
        initialize(null);   
    }   
       
    public ArrayStack(int newcapacity){   
           
        if (newcapacity < this.initalSize)   
            throw new IllegalArgumentException("The new capacity is too small!");   
           
        initalSize = newcapacity;   
           
        initialize(null);   
    }   
       
    public ArrayStack(E[] items) {   
           
        initialize(items);   
    }   
       
    public ArrayStack(Collection<E> collection) {   
           
        initialize(collection.toArray());   
    }   
       
    private void initialize(Object[] items){   
           
        if (items == null || items.length == 0){   
               
            stack = new Object[initalSize];   
               
            head = 0;   
               
            tail = 0;   
        }   
        else{   
               
            stack = new Object[items.length + 1];   
               
            System.arraycopy(items, 0, stack, 0, items.length);   
               
            head = items.length;   
               
            tail = 0;   
        }   
    }   
  
       
    @SuppressWarnings("unchecked")   
    public E pop(){   
           
        if (size() == 0)   
            throw new NoSuchElementException();   
           
        if (head == 0)   
            head = stack.length;   
           
        Object ret = stack[--head];   
           
        loseWeight();   
           
        return (E)ret;   
    }   
       
    public void push(E item){   
           
        increaseWeight();   
           
        stack[head++] = item;   
  
        if (head == stack.length)   
            head = 0;   
    }   
       
    @SuppressWarnings("unchecked")   
    public E peek(){   
           
        if (size() == 0)   
            throw new NoSuchElementException();   
           
        if (head == 0)   
            return (E)stack[stack.length - 1];   
        else  
            return (E)stack[head-1];   
    }   
       
    public boolean isEmpty(){   
           
        return (size() == 0);   
    }   
       
    public int size(){   
           
        return head >= tail ? head - tail : head + stack.length - tail;   
    }   
       
    public boolean increaseWeight(){   
           
        if (size() == stack.length - 1){   
               
            Object[] newStack = new Object[stack.length * 2];   
               
            System.arraycopy(stack, 0, newStack, 0, stack.length);   
               
            stack = newStack;   
               
            return true;   
        }   
           
        return false;   
    }   
       
    public boolean loseWeight(){   
           
        if (size() == stack.length / 4){   
               
            Object[] newStack = new Object[stack.length/2];   
               
            if (head >= tail){   
                   
                System.arraycopy(stack, tail, newStack, 0, size());   
                   
            }   
            else{   
                   
                System.arraycopy(stack, tail, newStack, 0, stack.length-tail);   
                   
                System.arraycopy(stack, 0, newStack, stack.length-tail, head);   
            }   
  
            tail = 0;   
               
            head = size();   
               
            return true;   
        }   
           
        return false;   
    }   
} 

//本篇文章来源于csdn论坛：http://topic.csdn.net/u/20100201/21/8abd9e46-c84c-4ba1-bf28-3a8ed907bd94.html
原文链接http://edu.codepub.com/2009/1003/16063.php