基于数组实现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