Java 自定义Stack栈类及应用

栈是存放对象的一种特殊容器，在插入与删除对象时，这种结构遵循后进先出（ Last-in-first-out，LIFO）的原则。java本身是有自带Stack类包，为了达到学习目的已经更好深入了解stack栈，自己动手自建java stack类是个很好的学习开始：

自建Java Stack 类

Stack 类：

package com.stack;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * Stack Class
 * @author ganyee
 *
 */
public class Stack {
    //Define capacity constant:CAPACITY
    private static final int CAPACITY = 1024;
    //Define capacity
    private static int capacity;
    //Define the top position of stack 
    //top = -1 meaning that the stack empty
    private static int top = -1;
    //Basic Object class array
    Object[] array;
    //Initialize the capacity of stack
    public Stack() {
        this.capacity = CAPACITY;
        array = new Object[capacity];
    }

    //Get the size of stack
    public int getSize(){
        if(isEmpty()){
            return 0;
        }else{
            return top + 1;
        }
    }

    //Get whether stack is empty
    public boolean isEmpty(){
        return (top < 0);
    }

    //Get the top element of stack
    public Object top() throws ExceptionStackEmpty{

        if(isEmpty()){
            throw new ExceptionStackEmpty("Stack is empty");
        }
        return array[top];

    }

    //Push element to stack
    public void push(Object element) throws ExceptionStackFull{
           if(getSize()== CAPACITY){
               throw new ExceptionStackFull("Stack is full");
           }
           array[++ top] = element;
    }

    //Pop element from stack
    public Object pop() throws ExceptionStackEmpty{
        if(isEmpty()){
            throw new ExceptionStackEmpty("Stack is empty");
        }
        return array[top --];
    }

    //Get the all elements of stack
    public String getAllElements() throws ExceptionStackEmpty{
        String[] arr = new String[top + 1];
        if(!isEmpty()){
            for(int i = 0;i < getSize();i ++){
                arr[i] = (String)array[i];
            }
        }
        return Arrays.toString(arr);
    }
}

自定义ExceptionStackEmpty异常类（关于如何自定义异常类可以看相关博客）

package com.stack;

public class ExceptionStackEmpty extends Exception {

    //Constructor
    public ExceptionStackEmpty(){

    }

    //Define myself exception construct with parameters
    public ExceptionStackEmpty(String string){
        super(string);
    }
}

自定义ExceptionStackFull异常类

package com.stack;

public class ExceptionStackFull extends Exception {

    //Constructor
        public ExceptionStackFull(){

        }

        //Define myself exception construct with parameters
        public ExceptionStackFull(String string){
            super(string);
        }
}

测试类:

package com.stack;

public class StackTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Stack stack= new Stack();
        System.out.println(stack.getSize());
        System.out.println(stack.isEmpty());
        try {
            stack.push(8);
            stack.push(3);
            stack.push(4);
            stack.push(7);
            stack.push(1);
            stack.push(8);
            stack.push(3);
            stack.push(4);
            stack.push(7);
            stack.push(1);
            System.out.println(stack.getSize());
            System.out.println(stack.top());
            System.out.println(stack.getAllElements());

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

        } catch (ExceptionStackFull e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (ExceptionStackEmpty e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

测试结果：

0
true
10
1
[8, 3, 4, 7, 1, 8, 3, 4, 7, 1]
1
7
4
3
8
1
7
4
3
8

栈的应用：符号匹配

下面，我们将借助一个栈结构 S，通过对算术表达式自左向右的一遍扫描，检查其中的括号是
否匹配。
假设算术表达式为 X = “x0x1x2…xn-1”，其中 xi 可以是括号、常数、变量名或者算术运算符。我
们依次检查 X 中的各个符号，非括号的符号都可以忽略。若遇到左括号，则将其压入栈 S 中；若遇到右括号，则将栈顶符号弹出并与该右括号对比。如果发现某对括号不匹配，或者遇到右括号时栈为空，或者整个表达式扫描过后栈非空，都可以断定括号不匹配。
在按照以上规则扫描完所有字符后，若栈为空，则说明括号是匹配的。如果按照前面对栈的实现，每一 push()和 pop()操作都只需常数时间，因此对于长度为 n 的算术表达式，上述算法需要运行 O(n)的时间。
该算法的伪代码描述如 算法二.1 所示：

package com.stack;

public class MatchClass {

    public static boolean Match(String str) throws ExceptionStackFull, ExceptionStackEmpty{
        Stack stack = new Stack();
        str = str.replaceAll(" ","");
        char s;
        for(int i = 0;i < str.length();i ++){
            if(str.charAt(i) == ‘(‘ || str.charAt(i) == ‘{‘ || str.charAt(i) == ‘[‘)
                stack.push(str.charAt(i));
            else{
                if(stack.isEmpty())
                    return false;
                else{
                    s = str.charAt(i);
                    switch(s){
                    case ‘)‘:
                        if((Character)stack.pop() != ‘(‘)
                            return false;
                        break;
                    case ‘}‘:
                        if((Character)stack.pop() != ‘{‘)
                            return false;
                        break;
                    case ‘]‘:
                        if((Character)stack.pop() != ‘[‘)
                            return false;
                        break;
                    }
                }

            }
        }
        if(stack.isEmpty()){
            return true;
        }else{
            return false;
        }
    }
}

package com.stack;

public class ParentMatch {

    public static void main(String[] args) {

        MatchClass match = new MatchClass();
        //String str = "()({})";  //Match
        //String str = "()({}) {([()[]])}";//Match
        //String str = "([]{)";//Not match
        //String str = ")([()] {}";//Not match
        String str = "([())]{}";//Not match
        try {
            if(!match.Match(str)){
                System.out.println(str + ": Not Macth");
            }else{
                System.out.println(str + ": Macth");
            }
        } catch (ExceptionStackFull e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExceptionStackEmpty e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

测试结果：

()({}): Macth
()({}) {([()[]])}: Macth
([]{): Not Macth
)([()] {}: Not Macth
([())]{}: Not Macth

文章参考：数据结构与算法（ Java 描述）邓俊辉 著
转载请注明出处，谢谢！
http://blog.csdn.net/github_27609763/article/details/46420149