JAVA复习---------------------手写ArrayList（全面方法）

做任何事都应该持有认真的态度。

因为是复习，再加上一直想写一些轮子，后期的代码会一起上传到我的github上，可能会很久，因为还有很多其它的知识没有学习，不过我会一直保持更新的.

http://www.github.com/YangGuangSuccess

解释：其中大家一些没有见过的异常是我自义的，所以不必纠结于此，YList接口只是定义了规范，并没有其它实际作用，希望大家有所收获

YArrayList:

package com.yg.collection.list.yarraylist;
/*
 *
 *@ClassName ArrayList
 *@Description TODO      顺序线性表的具体实现
 *@Author NEVER FORGET ONE
 *@Date 2019/5/6 13:31
 *
 */

import com.yg.collection.list.YList;


import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.Arrays;

public class YArrayList<T> implements YList<T> ,
                Serializable ,Cloneable{
    //序列化ID
    private static final long serialVersionUID = -5320233311646864148L;

    //YArrayList 最大容量
    private static final int MAX_CAPACITY= Integer.MAX_VALUE-8;


    //为了避免浪费序列化浪费空间，所以以 transient 修饰
    private transient Object[] elementData;


    //元素数量
    private transient int size;



    /******************-------------------------*************************/


    //空构造函数，默认初始化长度为 1
    public YArrayList(){
        this(1);
    }



    //以用户指定的长度初始化
    public YArrayList(int initCapacity){
        if(initCapacity <= 0){
            throw new YIllegalNumberException("初始化容量错误");
        }else{
            this.elementData = new Object[initCapacity];
        }
    }




    //支持数组初始化
    public YArrayList(T[] initArray) {
        checkIsNull(initArray);

        if(initArray.length == 0){
            throw new YIllegalValueException("不合理数值");
        }

        for(int i = 0 ; i != initArray.length; ++i){
            if(initArray[i] != null){
                ++size;
            }
        }
        this.elementData = initArray;
    }



    //支持以另一个 YList 构造
    public YArrayList(YList<T> yList){

        checkIsNull(yList);

        this.size = yList.size();

        this.elementData = YList.toArray(yList);
    }



    /*****************************-------***********************************/

    //添加元素,添加元素之前，判断数组空间是否足够
    //如果不够，则扩容2倍 , 右移 / 2 ， 左移 * 2
    @Override
    public boolean add(T element) {

        checkIsNull(element);

        if(size == elementData.length){

            elementData=ensureCapacity(size << 1);

        }

        elementData[size++] = element;

        return true;
    }





    //指定的下标插入元素
    @Override
    public boolean add(int index, T element) {

        checkIsNull(element);

        if(checkIndex(index)){

            //在容量正好等于size的情况下插入
            if(size == elementData.length){
                elementData = ensureCapacity(size + 1);
                return insert(index,element);
            }
            //在容量大于size的情况下插入
            else{
               return insert(index,element);
            }
        }

        throw new YIndexOutOfBoundException("不合理位置");
    }





    //将存储相同类型元素的集合添加到本集合
    @Override
    public boolean add(YList<T> yList) {
        
        checkIsNull(yList);
        
        int otherSize = yList.size();

        if (otherSize == 0) {
            throw new YIllegalOperationException("不支持添加空集");
        }
        if (size == 0) {
            elementData = Arrays.copyOf(YList.toArray(yList), otherSize);
            size += otherSize;
            return true;
        }

        int newCapacity = elementData.length - size >= otherSize ?
                elementData.length : size + otherSize;

        //如果 elementData空间足够充足，那么无需扩容
        if (newCapacity == elementData.length) {
            System.arraycopy(YList.toArray(yList), 0, elementData, size - 1, otherSize);
            size += otherSize;
            return true;

            //如果空间不足，则扩容至   /***合适容量***/
        } else {

            Object[] temp = new Object[newCapacity];
            System.arraycopy(elementData, 0, temp, 0, size);
            System.arraycopy(YList.toArray(yList), 0, temp, size, otherSize);

            elementData = temp;
            size += otherSize;
            return true;
        }
    }






    //移除在集合中第一次出现的元素
    // 移除成功返回 true
    // 如果移除失败或者没有指定元素，则返回 false
    @Override
    public boolean remove(T element) {

        if(size == 0){
            throw new YIllegalOperationException("非法操作");
        }

        checkIsNull(element);

        return removeElement(element);
    }





    //移除指定位置的元素,如果集合为空，调用此方法返回 将抛出异常
    public T remove(int index){

        if(size == 0){
            throw new YIllegalOperationException("非法操作");
        }

        if(checkIndex(index)){
            Object temp = elementData[index];
            if(size == 1){

                elementData = new Object[--size];
                return (T)temp;
            }
            removeElementByIndex(index);
            return (T)temp;
        }

        throw new YIndexOutOfBoundException("不合理位置");
    }




    //获取元素
    @Override
    public T get(int index) {

        if(checkIndex(index)){

            return (T)elementData[index];

        }

        throw new YIndexOutOfBoundException("不合理位置");
    }





    //替换指定元素，返回被替代的元素
    @Override
    public T set(int index, T element) {

        checkIsNull(element);

        if(checkIndex(index)){

            Object temp = elementData[index];

            elementData[index] = element;

            return (T)temp;
        }

        throw new YIndexOutOfBoundException("不合理位置");
    }



    //返回元素数量
    @Override
    public int size() {
        return size;
    }



    //清空
    @Override
    public boolean clear() {
        return clearElementData();
    }




    //是否包含某个元素
    @Override
    public boolean isContain(T element) {

        checkIsNull(element);

        for(int i = 0 ; i != size; ++i){
            if(elementData[i].equals(element)){
                return true;
            }
        }
        return false;
    }



    //返回元素在集合中第一次出现的下标，如果没有，则返回 -1
    public int indexOf(T element){

        checkIsNull(element);

        for(int i = 0 ; i != size ; ++i){
            if(elementData[i].equals(element)){
                  return i;
            }
        }
        return  -1;
    }




    //返回元素在集合中最后一次出现的下标，如果没有，则返回 -1
    public int lastIndexOf(T element){

        checkIsNull(element);

        for(int i = size - 1 ; i >= 0 ; --i){
            if(elementData[i].equals(element)){
                return i;
            }
        }
        return  -1;
    }



    //是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }





    //反序列化
    private void readObject(ObjectInputStream objectInputStream)
    throws IOException , ClassNotFoundException{
        objectInputStream.defaultReadObject();

        //读取元素数量

        size = objectInputStream.readInt();

        if(size < 0){
            throw new YIllegalNumberException("反序列化容量错误");
        }
        if(size == 0){
            elementData = new Object[0];
        }

        //读取 elementData
        Object[] temp = new Object[size];
        for(int i = 0 ; i != size; ++i){
            temp[i] = objectInputStream.readObject();
        }
        elementData = temp;
    }





    //序列化
    private void writeObject(ObjectOutputStream objectOutputStream)
    throws IOException{
            objectOutputStream.defaultWriteObject();

            //先序列化元素数量，这样方便反序列化的时候构造 elementData
            objectOutputStream.writeInt(size);

            //写入 elementData
            for(int i = 0 ; i != size ; ++i){
                objectOutputStream.writeObject(elementData[i]);
            }

    }





    /**
     *  返回指定集合的数组视图
     */
    public static <T>T[] toArray(YArrayList<T> arrayList){

        checkIsNull(arrayList);

        Class clazz = arrayList.getClass();
        try{

            Field field = clazz.getDeclaredField("elementData");

            T[] temp = (T[]) field.get(arrayList);

            return temp;

        }catch(NoSuchFieldException noSuchFieldException){
            noSuchFieldException.printStackTrace();
        }catch(IllegalAccessException illegalAccessException){
            illegalAccessException.printStackTrace();
        }
        return null;
    }





    //重写 equals 方法
    @Override
    public boolean equals(Object object) {
        if(this == object){
            return true;
        }
        if(!(object instanceof YList)){
            return false;
        }
        //比较 elementData 的元素是否相等
        if(object != null){
            YArrayList yArrayList = (YArrayList)object;
            if(size != yArrayList.size()){
                return false;
            }
            Object[] temp = YArrayList.toArray(yArrayList);
            for(int i = 0 ; i != size ; ++i){
                if(!elementData[i].equals(temp[i])){
                    return false;
                }
            }
            return true;
        }
        return false;
    }




    //重写 HashCode
    public int hashcode() {
        int hash = 17;
        hash = 31 * hash +  elementData.hashCode() ;
        hash = 31 * hash + (int)size^(size >>> 32);
        return hash > 0 ? hash : -hash;
    }




    //覆写 clone 方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        YArrayList<?> yArrayList = (YArrayList<?>) super.clone();
        yArrayList.elementData  = Arrays.copyOf(elementData,size);
        return yArrayList;
    }



    //覆写 toString
    @Override
    public String toString(){
        if(size == 0){
            return "[]";
        }

            StringBuilder result = new StringBuilder("[");
            for(int i = 0 ; i != size ;++i){
                result.append(elementData[i]);
                if(i != size - 1){
                    result.append(", ");
                    continue;
                }
                return result.append("]").toString();
            }
            return null;
    }



/*********************************内部函数******************************************/

    //数组扩容
    private Object[] ensureCapacity(int newCapacity){
        if(newCapacity >= MAX_CAPACITY){
            throw new YVMOutMemoryOfException("内存不足");
        }
        Object[] temp = new Object[newCapacity];
        System.arraycopy(elementData,0,temp,0,size);
        return temp;
    }





    //插入元素的位置:  1: 头位置   2 : 中间位置   3 : 末尾
    private boolean insert(int index,T element){
                //头位置插入
        if(index == 0){
            System.arraycopy(elementData,0,elementData,1,size);

            elementData[index] = element;

                //末尾插入
        }else if(index == size - 1){

            elementData[size] = elementData[index];
            elementData[index] = element;

        }else{

            int i = size;
            for(; i >= index;){
                elementData[i] = elementData[--i];
            }
            elementData[index] = element;

        }
        ++size;
        return true;
    }






    //移除元素位置 : 1: 头位置   2 : 中间位置    3: 末尾
    //移除条件 : size == 1 , size > 1
    private boolean removeElement(T element){

        if(size == 1){
            if(elementData[0].equals(element)){
                elementData[size--] = null;
                return true;
            }
            return false;
        }

        for(int i = 0 ; i != size ; ++i){
            if(elementData[i].equals(element)){
                return removeElementByIndex(i);
            }
        }
        return false;
    }





    //删除指定位置的元素
    private boolean removeElementByIndex(int index){

        //头位置移除
        if(index == 0){
            elementData = Arrays.copyOfRange(elementData,index+1,size);
            --size;

            return true;

            //末尾移除
        }else if(index == size - 1){
            elementData = Arrays.copyOfRange(elementData,0,--size);

            return true;

            //中间移除
        }else{
            elementData[index] = null;
            int removeIndex = index;
            for(; removeIndex < size-1;){
                elementData[removeIndex] = elementData[++removeIndex];
            }
            elementData = Arrays.copyOfRange(elementData,0,--size);

            return true;
        }
    }





    //检查非空 Object
    private static void checkIsNull(Object obj){
        if(obj == null){
            throw new YIllegalValueException("不合理数值");
        }
    }




    //检查 index 是否合理
    private boolean checkIndex(int index){
       return index >= 0 && index < size;
    }




    //清空 elementData
    private boolean clearElementData(){
        for(; size > 0 ;){
            elementData[--size] = null;
        }
        return true;
    }
}