基于Array实现ArrayStack

基于泛型数组实现：

package com.lt.datastructure.Array;
/**
 * 泛型数组
 *
 * @param <E>
 */
public class Array1<E> {     
        private  E[] data;
           private int size;
           
           public Array1(int capacity){
               data = (E[]) new Object[capacity];
               size = 0;
           }
           public Array1(){ 
              this(10);
           }
           //获得数组元素个数
           public int getSize(){
               return size;
           }
           
           //获得数组容量
           public int getCapacity(){
               return data.length;
           }
           
           //判断数组是否为空
           public boolean isEmpty(){
               return size==0;
           }
           
           //向指定位置添加元素
           public void add(int index, E e){
               //判断插入位置，需要在0到size之间
               if(index<0 || index>size){
                  throw new IllegalArgumentException("AddLast failed. Required 0=<index<size.");
               }
               //保证数组有足够空间容纳
               if(size == data.length){
                    resize(2*data.length);
               }
               //移位插入,index到size-1的位置的元素向后移位
               for(int i=size-1; i>=index ; i--){
                   data[i+1] = data[i];
               }
               data[index] = e;
               size++;
            }
           
            //数组扩容
               private void resize(int capacity) {
               E[] newData = (E[]) new Object[capacity]; 
               for(int i=0; i<size; i++){
                   newData[i] = data[i];
               }
               data = newData;
            }
        
           //向数组末尾添加一个元素
           public void addLast(E e){
              add(size,e);
           }
           
           //向数组头添加元素
           public void addFirst(E e){
               add(0,e);
           }
           
           //获取索引位置的元素
          public E get(int index){
               if(index<0 || index>=size){
                   throw new IllegalArgumentException("index is illegal");
               }
               System.out.println(data[index]);
               return data[index];
           }
           
           //设置指定位置的元素
           public void set(int index,E e){
               if(index<0 || index>=size){
                   throw new IllegalArgumentException("index is illegal");
               }
               data[index] = e;
           }
           
           //查找是否有元素e
           public boolean contains(E e){
               for(int i=0 ; i<data.length ; i++){
                   if(data[i].equals(e))
                       return true;
               }
               return false;
           }
           
           //查找索引
           public int find(E e){
             for(int i=0; i<data.length; i++){
                 if(data[i].equals(e))
                     return i;
             }
             return -1;
           }
           
           //删除指定位置元素,返回删除的元素
           public E remove(int index){
               if(index<0||index>=size){
                  throw new IllegalArgumentException("index is illegal"); 
               }
               E ret = data[index];
               for(int i = index+1;i<size;i++){
                   data[i-1] = data[i];
               }
               size--;
//               data[size]=null;非必要loitering objects != memory leak
               if(size==data.length/2){
                   resize(data.length/2);
               }
               
               return ret;
           }
           
           //移除第一个元素
           public E removeFirst(){
               return remove(0);
           }
           
           //移除最后一个元素
           public E removeLast(){
               return remove(size-1);
           }
           
           //移除某个元素
           public void removeElement(E e){
               int index = find(e);
               if(index!=-1)
               {
                   remove(index);
               }
           }
           
           @Override
           public String toString(){
               StringBuilder res = new StringBuilder();
               res.append(String.format("Array:size = %d , capacity = %d\n",size,data.length));
               res.append("[");
               for(int i = 0; i<size ; i++){
                   res.append(data[i]);
                   if(i!=size - 1)
                       res.append(",");
               }
               res.append("]");
               return res.toString();
           }
           
           public E getLast(){
               return get(size-1);
           }
           public E getFirst(){
               return get(0);
           }
    }

 

栈的实现：ArrayStack：

package com.lt.datastructure.stackqueue;

import com.lt.datastructure.Array.Array1;

public class ArrayStack<E> implements Stack<E> {
    
    Array1<E> array;
    
    public ArrayStack(int capacity){
        array = new Array1<>(capacity);
    }
    
     public ArrayStack() {
       array = new Array1<>();
    }
    @Override
    public int getsize() {
        return array.getSize();
    }

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

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

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

    @Override
    public E peek() {    
        return array.getLast();
    }
   
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack:");
        res.append('[');
        for(int i = 0; i<array.getSize() ; i++){
            res.append(array.get(i));
            if(i!= array.getSize()-1){
                res.append(",");
            }
        }
            res.append("] top");
        
        return res.toString();
    }
    

}

测试：