Java ToyProgam LunacyDoctor implements IO and Sequence Stack

前面写了链栈 http://blog.csdn.net/nyzhl/archive/2007/06/18/1656153.aspx
现在写了个程序实现顺序栈


//Coding by zhaohongliang


import java.io.*;




public class LunacyDoctor ...{




public static void main(String[] args) ...{


BufferedReader sr =new BufferedReader(


new InputStreamReader (System.in) );


String inString = null;


String[] temp = null;




try ...{


inString = sr.readLine();




while(inString!=null) ...{




if(inString.equalsIgnoreCase("exit")) ...{


System.exit(-1);


}


temp = inString.split(" ");


SeqStack<String> ss = new SeqStack<String>(temp.length);




for(String s : temp) ...{


ss.push(s);


}




while(!ss.empty()) ...{


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


}


System.out.println();


inString=sr.readLine();


}


sr.close();


}




catch(IOException e1) ...{


System.out.println("Error:IO Error.");


}




catch(EmptyStackException e2) ...{


System.out.println("Error:Popped an empty Stack.");


}




catch(StackOverFlowException e3) ...{


System.out.println("Error:Stack over flow.");


}


}


}




class SeqStack<T> ...{


private final int size;


private T[] elem;


private int top;




public SeqStack(int size) ...{


this.top = -1;


this.size = size;


elem = (T[])new Object[size];


//elem = new T[size]; 此句JDK会报错：创建泛型数组


}




public boolean empty() ...{


return top==-1 ? true : false ;


}




public boolean full() ...{


return elem.length-1==top ? true : false;


}




public void push(T item) ...{


if(full()) throw new StackOverFlowException();


top ++ ;


elem[top] = item;


}




public T pop() ...{


if(empty()) throw new EmptyStackException();


top -- ;


return elem[top+1];


}




public T peek() ...{


if(empty()) throw new EmptyStackException();


return elem[top];


}


}




class StackOverFlowException extends RuntimeException ...{}




class EmptyStackException extends RuntimeException ...{}


//在java.util包里也有EmptyStackException

可以看出，顺序栈是基于数组的，数组声明时必须声明长度。程序可扩展性差。而且数组的地址空间是固定的。如果强行重新构造数组（ArrayList）将造成写操作执行效率低下。但是数组的地址是可计算的，所以在读写时的效率很高。
而链栈是基于链表的，只要你内存够，就可以无限扩展。但是在读写操作时，要找到目标对象比较耗费资源。但是栈只是针对栈顶操作，就不存在这个问题了。所以我觉得综合来看，还是链栈比较好用。不知道JRE里的栈是怎么实现的。