java中Stack的實現

棧結構是一種操作受限的線性表結構，也就是說它的內部實現還是數組，只是操作有些特殊。棧特點就是先進後出，只在棧頂操作元素，就好比一個底座密封的瓶子，往瓶口放東西下去，最先進去的被壓在最下面，只能最後出來，而我們的棧結構也是如此。棧結構是List接口的實現，所以我們的List接口的設計請參考上一篇文章
java實現ArrayList
不僅僅只是接口的設計一樣的，在實現類中除了子類特有的幾個方法實現以外，其它方法都和上一篇博客一樣。下面貼上代碼：

package com.yxc.util;

import java.util.Iterator;

/**
 * 棧的實現
 * 其實我們把棧看成是有特殊操作的集合，只操作棧頂元素的一種結構。
 * 內部同樣可以使用數組去實現，我們假定棧頂元素就是數組下標爲0位置的元素
 * 實現MyList,只是在這個類中多了幾個操作 其它的都和MyArrayList實現一樣的
 * @param <E>
 */
public class MyStack<E> implements MyList<E>{
    //定義數組
    private E[] elements;
    //定義初始容量
    private int initCapacity;
    //默認擴寬長度
    private int entendsCapacity;
    //集合的長度
    private int size=0;

    //下面通過構造函數鏈來初始化
    //如果無參構造，那我們初始化一些值
    public MyStack(){
        this(10,10);
    }
    //只給點初始容量，那我們默認擴容10
    public MyStack(int initCapacity){
        //調用自己的構造方法
        this(initCapacity,10);

    }
    public MyStack(int initCapacity,int entendsCapacity){
        //判斷一下參數的合法性
        if(initCapacity<0||entendsCapacity<0){
            //自己拋異常還是很爽的，可以自己寫異常，然後拋出
            throw new IllegalArgumentException("非法參數");
        }
        elements=(E[])new Object[initCapacity];
        this.entendsCapacity=entendsCapacity;
    }

    //擴容方法
    public void ensureCapacity(int newCapacity){
        //判斷容量是不是正確
        if(elements.length>newCapacity){
           return;
        }
        //將數組保留下來
        E[] oldElements=elements;
        //創建一個新的數組
        E[] newElement=(E[]) new Object[newCapacity];
        //將舊數組的元素複製到新數組中
        System.arraycopy(oldElements,0,newCapacity,0,size);
        //將新數組的引用給原數組
        elements=newElement;
        //將沒用的數組引用釋放
        oldElements=null;
    }

    //檢查下標
    public void checkIndex(int index){
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("數組下標越界，請檢查下標"+index);
        }
    }

    /**
     * 入棧操作 也就是將元素插入到棧頂
     */
    public void push(E elem){
        //判斷棧是不是滿了 滿了就要擴容 但是我們在add方法裏面就有擴容這一步，所以我們這邊就不寫
        //對於入棧，不就是在棧頂元素添加元素，棧頂元素就是下標爲0的位置
        add(0,elem);
    }

    /**
     * 返回棧頂元素，並且刪除 也就是出棧
     */
    public E pop(){
        //先保留元素
        E temp=elements[0];
        //然後刪除元素
        remove(0);
        return temp;
    }

    /**
     * 返回棧頂元素，但是不刪除棧頂元素
     */
    public E peek(){
        //返回棧頂元素
        return elements[0];
    }
    @Override
    public void add(E elem) {
         add(0,elem);
    }

    @Override
    public void add(int index, E elem) {
        checkIndex(index);
        //判斷是不是要擴容
        if(elements.length==size){
            ensureCapacity(size+entendsCapacity);
        }
        //移動元素 賦值  自增
        System.arraycopy(elements,index,elements,index+1,size-index);
        elements[index]=elem;
        size++;
    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E e) {
        return null;
    }

    @Override
    public int indexOf(E elem) {
        return 0;
    }

    @Override
    public int lastIndexOf(E elem) {
        return 0;
    }

    @Override
    public boolean Contain(E e) {
        return false;
    }

    @Override
    public E remove(int index) {
        checkIndex(index);
        //保留數據
        E temp=elements[index];
        //複製元素
        System.arraycopy(elements,index+1,elements,index,size-index-1);
        size--;
        return temp;
    }

    @Override
    public boolean remove(E elem) {
        return false;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void clear() {
        size=0;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void trimToSize() {

    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }
}

說明一下，沒有實現的方法參考上一篇博文，銜接在上面。