泛型动态栈的实现——Java

栈的功能

将栈的基本功能定义在接口中，使栈类实现接口即可。

public interface Stack<E> {
    int getSize();//存储了多少数据
    boolean isEmpty();
    void push(E e);//顶部放入元素
    E pop();//取出并返回顶部元素
    E peek();//返回顶部元素
}

栈的实现

在动态泛型数组Array类基础上实现。

Array类：

/*
动态泛型数组 支持所有类元素的存储
 */
public class Array<E> {//数组中使用类型E 泛型
    private int size;
    private E[] datas;

    //构造函数,capacity初始容量，默认为2
    public Array(int capacity){
        //datas=new E[capacity];//E类型不能直接new
        datas=(E[])new Object[capacity];//java中E[]不能直接new，由Object转化转化为E[]子类
    }
    public Array(){
        datas=(E[])new Object[2];
    }

    //查看数据数量
    public int getSize(){
        return size;
    }
    //查看是否为空
    public boolean isEmpty(){
        return (size==0);
    }
    //查看数组内容
    @Override//表示覆盖父类函数
    public String toString(){
        StringBuilder str=new StringBuilder();//StringBuilder的使用
        str.append("capacity:"+datas.length+"\nsize:"+size+"\ndatas:");
        for(int i=0;i<size;i++)
            str.append(datas[i]+"\t");
        return str.toString();
    }
    //根据下标查看数据
    public E get(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Get Failed.Index is illegal");
        }
        return datas[index];
    }
    //查看最后一个数据
    public E getLast(){
        return get(size-1);
    }
    //查看第一个数据
    public E getFirst(){
        return get(0);
    }
    //根据下标修改元素
    public boolean set(int index,E data){
        if(index<0||index>=size)
            return false;
        else{
            datas[index]=data;
            return true;
        }
    }

    //删除指定位置数据并返回值
    public E remove(int index){
        if(index<0||index>=size)
            throw new IllegalArgumentException("请求不合法，Array.remove(int index)操作失败");
        E ret=datas[index];
        for(int i=index;i<size-1;i++){
            datas[i]=datas[i+1];
        }
        size--;
        datas[size]=null;//置为空才能进行垃圾回收 lolitering objects闲逛元素
        return ret;
    }
    //删除最后一个元素并返回值
    public E remove(){
        return remove(size-1);
    }
    //根据数值获得索引
    public int find(E data){
        for(int i=0;i<size;i++){
            if(datas[i].equals(data))//类元素相等用equals,值比较
                return i;
        }
        return -1;//-1下标无效
    }
    //获取容量
    public int getCapacity(){
        return datas.length;
    }
    //增加元素
    public void add(E data){
        if(size==datas.length){//此元素将放入size处
            E[] newDatas=(E[])new Object[datas.length*2];
            System.arraycopy(datas,0,newDatas,0,datas.length);
            newDatas[size++]=data;
            datas=newDatas;
        }
        else {
            datas[size++] = data;
        }
    }
}

ArrayStack类：

public class ArrayStack<E> implements Stack<E> {
    Array<E> array;

    public ArrayStack(int capacity){//泛型类构造函数类名后不加<>
        array=new Array<E>(capacity);
    }
    public ArrayStack(){
        array=new Array<E>();
    }

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

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

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

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

    @Override
    public E peek(){
        return array.getLast();
    }//已经在接口中定义的函数

    public int getCapacity(){
        return array.getCapacity();
    }//未曾在接口中定义的函数
}

简单测试：

public class TeatArrayStack {
    public static void main(String[] args){
        ArrayStack<String> as=new ArrayStack<>(2);//定义初始容量为2的栈
        for(int i=0;i<6;i++){
            as.push("a"+i);
            System.out.print(as.peek()+"\t");
        }//依次放入a0-a5字符串
        System.out.println();
        for(int i=0;i<6;i++){
            System.out.print(as.pop()+"\t");
        }//从顶部取5次数据
    }
}