基于动态数组实现栈（利用栈去实现括弧匹配）

class Solution {
    public class Array<E> {
    private E[] data;
    private int size;

    /**
     *
     * @param capacity
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * the default capacity is 10
     */
    public Array() {
        this(10);
    }

    /**
     *@return the current data length of the array
     */
    public int getSize() {
        return size;
    }

    /**
     * Determines whether the array is empty
     * @return  false or true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * get the Array capacity
     * @return  Array capacity
     */
    public int capacity() {
        return data.length;
    }

    /**
     * Insert an element on an index
     * @param index
     * @param e
     */
    public void add(int index,E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed.Array is full");
        if (size == data.length) {
            resize(2*data.length);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size++;
    }

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    public void addLast(E e) {
        add(size,e);
    }
    /**
     * Get the value of the index location
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed,Array is full");
        return data[index];
    }

    /**
     * Specify index insert value
     * @param index
     * @param e
     */
    public void set(int index,E e) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("set failed,Array is full");
        data[index] = e;
    }

    /**
     * Determine whether an array contains e
     * @param e
     * @return
     */
    public boolean contains(E e) {
        if (find(e) != -1)
            return true;
        else
            return false;
    }

    /**
     *find the index of "e" in the array
     * @param e
     * @return index of "e"
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }

    /**
     * remove elements from index positions
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size)
            throw  new IllegalArgumentException("remove failed,array is full");
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return ret;
    }

    public E removeFirst() {
        return remove(0);
    }

    public void removeElement(E e) {
        if (find(e) != -1) {
            int index = find(e);
            for (int i = index + 1; i < size; i++)
                data[i-1] = data[i];
            size--;
        }
    }

    /**
     * remove all "e" from the array
     * @param e
     */
    public void removeElements(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                remove(i);
                i--;
            }
        }
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n",size,data.length));
        res.append("[");
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i < size - 1)
                res.append(",");
        }
        res.append("]");
        return res.toString();
    }

    public E removeLast() {
        return remove(size - 1);
    }

    public E getLast() {
        return data[size - 1];
    }
}
    public class ArrayStack<E> implements Stack<E> {
    /**
     * Based on Dynamic Array
     */
    private Array<E> array;

    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }

    public ArrayStack() {
        array = new Array<>();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        str.append("Stack[");
        for (int i = 0; i < array.getSize() ; i++) {
            str.append(array.get(i));
            if(i < array.getSize() - 1) {
                str.append(",");
            }
        }
        str.append("] top");
        return String.valueOf(str);
    }
}
    public interface Stack<E> {
    void push(E e); //push e into the stack
    E pop();    //pop stack top element
    E peek();   //view stack top elements
    int getSize();  //view stack length
    boolean isEmpty();  //check if the stack is empty
}
    public boolean isValid(String s) {
        ArrayStack<Character> arrayStack = new ArrayStack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == ‘(‘ || c == ‘{‘ || c == ‘[‘) {
                arrayStack.push(c);
            } else {
                if (arrayStack.isEmpty())
                    return false;
                char topChar = arrayStack.pop();
                if (c == ‘)‘ && topChar != ‘(‘)
                    return false;
                if (c == ‘]‘ && topChar != ‘[‘)
                    return false;
                if (c == ‘}‘ && topChar != ‘{‘)
                    return false;
            }
        }
        return arrayStack.isEmpty();
    }
}