import java.util.Arrays;

public class MyArrayList implements IList{

    //基本成員方法

     public int [] element ;
     public int usedSide;
     public static final int DEFAULT_CAPACITY =10;

     public MyArrayList(){
        this.element = new int[DEFAULT_CAPACITY];
     }



    @Override
    public void add(int data) {
         //判斷是不是滿  -- 擴(kuò)容后進(jìn)行添加元素
        if (isFull()){
            grow();
        }
        this.element[this.usedSide] = data;
        usedSide++;

    }

    public boolean isFull(){
         return usedSide == this.element.length;
    }

    public void grow(){
        this.element = Arrays.copyOf(this.element,
                 2*element.length);
    }
    public void checkPosAdd(int pos,String mag) {
        if (pos < 0 || pos > usedSide) {
            throw new posIllegalityException(mag);
        }
    }

    @Override
    public void add(int pos, int data) {
         //判斷滿沒有
        if (isFull()){
            grow();
        }
        // 下表是不是合法的
        checkPosAdd(pos,"pos位置不合法");
        //交換數(shù)據(jù)
        for (int i = usedSide-1;i >= pos;i--){
            element[i] = element[i+1];
        }
        element[pos] = data;
        usedSide++;
    }

    @Override
    public boolean contains(int toFind) {

         for (int i = 0 ;i < usedSide ; i ++){
             if (this.element[i] == toFind){
                 return true;
             }
         }
        return false;
    }

    @Override
    public int indexOf(int toFind) {
        for (int i = 0 ;i < usedSide ; i ++){
            if (this.element[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int get(int pos) {
         if (isEmpty()){
             throw new emptyIllegalityException
                     ("空列表異常");
         }
         checkPos(pos,"get方法的pos越界異常");
         return element[pos];
    }

    //檢查越界異常
    public void checkPos(int pos,String mag){
         if (pos < 0 || pos >= usedSide){
             throw new posIllegalityException(mag); //調(diào)用異常
         }
    }


    public boolean isEmpty(){
         return this.usedSide == 0;
    }



    @Override
    public void set(int pos, int value) {
         checkPos(pos, "upset方法pos位置違法");
         //是不是空
        if(isEmpty()){
            throw new emptyIllegalityException("set方法空指針異常");
        }
         this.element[pos] = value;


    }


    @Override
    public void remove(int toRemove) {
         //判斷是不是空
        if (isEmpty()){
            throw new emptyIllegalityException("空鏈表異常");
        }

        int pos = indexOf(toRemove);
        if (pos < 0){
            throw new posIllegalityException("刪除位置異常");
        }
        //核心邏輯進(jìn)行
        for (int i = pos; pos < usedSide-1 ;i++ ){
            //在進(jìn)行add會將最后那個覆蓋
            this.element[i] = element[i+1];
        }
        usedSide--;



    }

    @Override
    public int size() {
     //判斷是不是空
        if(isEmpty()){
            throw new emptyIllegalityException("set方法空指針異常");
        }
        return this.usedSide;

    }

    @Override
    public void clear() {
         for (int i = 0;i < usedSide ;i++){
             this.element[i] = 0;
             //是引用類型是就要給到null
         }
         usedSide =0;
    }

    @Override
    public void display() {
         for (int i = 0 ; i < usedSide ;i++){
             System.out.println(element[i]+" ");
         }
        System.out.println();
    }
}

public class posIllegalityException extends RuntimeException {
    //構(gòu)造方法

    public posIllegalityException() {
    }

    public posIllegalityException(String message) {
        super(message);
    }
}

public class emptyIllegalityException extends RuntimeException {
    public emptyIllegalityException() {
    }

    public emptyIllegalityException(String message) {
        super(message);
    }
}

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // 另一個靜態(tài)空數(shù)組常量
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray()可能返回的不是Object[]類型（如某些自定義集合），需轉(zhuǎn)換
        if (elementData.getClass() != Object[].class) {
            elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
    } else {
        // 集合c為空，賦值為空數(shù)組
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

System.out.println(list);

 for(int i = 0; i <= list.size()-1; i++{
        Integer ii = list.get(i);
       System.out.print(" "+ ii);
 }

    for (int x :list){
            System.out.print(x + " ");
        }

迭代器
     Iterator<Integer> it = list.iterator();
     while (it.hasNext()) {
          System.out.println(it.next()+ " ");
      }

        //迭代器
        ListIterator<Integer> it = list.listIterator();
        while (it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
//指定位置后開始
        ListIterator<Integer> it2 = list.listIterator(1);
        while (it2.hasNext()){
            System.out.print(it2.next()+ " ");
        }
        System.out.println();
//指定位置前開始
        ListIterator<Integer> it3 = list.listIterator(list.size());
        while (it3.hasPrevious()){   //返回值bool
            System.out.print(it3.previous()+ " ");
        }