public

class Stack<E> extends Vector<E> {　　//继承Vector，Vector和ArrayList几乎相同，都是通过数组保存数据，只不过方法有Synchronized修饰

    public Stack() {

    }

    public E push(E item) {　　//push，也就是add，把数据保存得add到数组的末尾

        addElement(item);　　

        return item;

    }

    public synchronized E pop() {　　//pop，也就是removeLast()，并且返回末尾值

        E       obj;

        int     len = size();　　//得到数组长度

        obj = peek();　　//得到数组末尾值

        removeElementAt(len - 1);　　//删除末尾元素

        return obj;

    }

    public synchronized E peek() {　　//peek，返回末尾元素，只是查询，不会删除

        int     len = size();

        if (len == 0)

            throw new EmptyStackException();

        return elementAt(len - 1);　　

    }

    public boolean empty() {　　//empty，是否为空

        return size() == 0;

    }

    public synchronized int search(Object o) {

        int i = lastIndexOf(o);

        if (i >= 0) {

            return size() - i;

        }

        return -1;

    }

}

public class MyStack<E> {　　

    private int maxDepth;　　//栈深度

    private Object[] elementData;　　//保存数据的数组

    private int top;　　//栈顶的位置，空栈为-1

    public MyStack() {

        this.maxDepth = 10;

        this.elementData = new Object[10];　　

        this.top = -1;

    }

    public MyStack(int initialCapacity) {

        this.maxDepth = initialCapacity;

        this.elementData = new Object[initialCapacity];

        this.top = -1;

    }

    public E push(E e) {

        ensureExplicitCapacity(top +1);

        elementData[++top] = e;

        return e;

    }

    public E pop(){

        E e = peek();

        elementData[top] = null;

        this.top--;

        return e;

    }

    public E peek() {

        return (E)elementData[top];

    }

    private void ensureExplicitCapacity(int minCapacity) {

        if (minCapacity - elementData.length > 0)

            grow(minCapacity);

    }

    private void grow(int minCapacity) {　　//扩容

        int oldCapacity = elementData.length;

        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)

            newCapacity = minCapacity;

        if (newCapacity - Integer.MAX_VALUE > 0)

            newCapacity = Integer.MAX_VALUE;

        this.maxDepth = newCapacity;

        elementData = Arrays.copyOf(elementData, maxDepth);

    }

    public int size() {

        return top + 1;

    }
　　public boolean isEmpty() {
　　　　return top == -1;
　　}

}

public static void main(String[] args) {

	MyStack<Integer> stack = new MyStack<Integer>();

	stack.push(1);

	stack.push(2);

	stack.push(3);

	int size = stack.size();

	for (int i = 0; i < size; i++) {

		System.out.print(stack.peek() + " ");

	}

	System.out.println("");

	for (int i = 0; i < size; i++) {

		System.out.print(stack.pop() + " ");

	}

}

输出结果：

3 3 3

3 2 1

for (int i = 0; i < stack.size(); i++) {

	System.out.print(stack.pop() + " ");

}

while (!stack.isEmpty()) {

	System.out.println(stack.pop());;

}

public static void main(String[] args) {

	MyStack<Character> stack = new MyStack<Character>();

	char[] chars = getInput().toCharArray();

	for (char c : chars) {

		stack.push(c);

	}

	while (!stack.isEmpty()) {

		System.out.print(stack.pop() + " ");;

	}

}

public static String getInput() {

	String s = null;

	try {

		InputStreamReader reader = new InputStreamReader(System.in);

		BufferedReader bufferedReader = new BufferedReader(reader);

		s = bufferedReader.readLine();

	} catch (IOException e) {

		e.printStackTrace();

	}

	return s;

}

public static boolean isValid(String s) {
    MyStack<Character> stack = new MyStack<>();
    char[] chars = s.toCharArray();
    for (char aChar : chars) {
        switch (aChar) {
            case '{':
                stack.push('}');
                continue;
            case '<':
                stack.push('>');
                continue;
            case '(':
                stack.push(')');
                continue;
            default:
                if (stack.isEmpty() || stack.pop() != aChar) {
                    return false;
                }

        }
    }
    return stack.isEmpty();
}