数据结构之堆栈java版

import java.lang.reflect.Array;

/*

具体原理在c++版已经说的很清楚，这里不再赘述，

就提一点：java的泛型具有边界效应，一旦离开作用域立马被替换为object类型，在new泛型数组需要借助反射。

*/

interface BaseStack<T>{
　　boolean push(T x);
　　boolean pop();
　　void clear();
　　T top();
}
public class JBStack<T> implements BaseStack<T>{
　　T[] mStack;
　　int mMaxSize,mIndex;
　　static public void main(String atgs[]){
　　　　JBStack<Integer> test=new JBStack<Integer>(Integer.class,10);
　　　　test.push(1);
　　System.out.println(""+test.top());
　　}
　　public JBStack(Class<T> type,int Size) {
　　　　// TODO Auto-generated constructor stub
　　　　mMaxSize=Size;
　　　　mIndex=-1;
　　　　mStack=(T[])Array.newInstance(type,mMaxSize);//注意这里new泛型数组的方式 java的泛型有边界替换的特性
　　}
　　@Override
　　public boolean push(T x) {
　　　　// TODO Auto-generated method stub
　　　　if(isFull()){
　　　　　　//over flow
　　　　　　return false;
　　　　}
　　　　mIndex++;
　　　　mStack[mIndex] = x ;
　　return true;
　　}
　　@Override
　　public boolean pop() {
　　　　// TODO Auto-generated method stub
　　　　if(isEmpyty()){
　　　　//empty
　　　　return false;
　　　　}
　　　　mIndex--;
　　　　return true;
　　}

　　@Override
　　public void clear() {
　　　　// TODO Auto-generated method stub
　　　　mIndex=-1;
　　}

　　@Override
　　public T top() {
　　　　// TODO Auto-generated method stub
　　　　return (T)mStack[mIndex];
　　}
　　boolean isEmpyty(){
　　　　if(mIndex==-1){
　　　　　　return true;
　　　　}
　　　　else{
　　　　　　return false;
　　　　}
　　}
　　boolean isFull(){
　　　　if(mIndex<mMaxSize){
　　　　　　return false;
　　　　}
　　　　else{
　　　　　　return true;
　　　　}
　　}
}