Java手写ArrayList

手写ArrayList

• ArrayList 是基于数组的实现，底层主要的难点是，数组移动，实现数组的删除或者添加，核心方法是，System.arraycopy(elementData, index, elementData, index + 1, size - index);
  代码实现，首先定义公共的接口：

public interface MyList<E> {

        void add (E e);

        E remove (int index);

        E get (int index);

        int size();

}

ArrayList 实现类：

package com.work.one.listUtils.impl;

import com.work.one.listUtils.MyList;

import java.util.Arrays;

/**
 * Created by 廖开雷 on 2020/2/3.
 */
@SuppressWarnings("all")
public class LklList<E> implements MyList<E> {
    //记录实际的元素的个数
    private int size = 0;

    //橙装元素的数组容器
    private Object[] elementData;

    public LklList() {
        elementData = new Object[10];
    }

    public LklList(int initCapacity) {
        if (initCapacity < 0) throw new IllegalArgumentException(" initCapacity is wrong");
        elementData = new Object[initCapacity];
    }

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

    @Override
    public E remove(int index) {
        rangeCheck(index);
        // 1 2 3 4 5
        Object e = elementData[index];
        System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
        elementData[size - 1] = null;
        size -- ;
        return (E) e;
    }

    @Override
    public E get(int index) {
        return (E)this.elementData[index];
    }

    @Override
    public void add(E o) {
        //1、判断是否扩容
        ensureCapcacity();
        //2、添加元素
        this.elementData[size++] = o;
    }

    public void add (E e, int index) {
        rangeCheck(index);

        ensureCapcacity();
        // 1 2 3 4 5
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        this.elementData[index] = e;
        size ++;
    }

    public void printCapacity () {
        System.out.println("now capacity is :" + this.elementData.length);
    }

    public void print () {
        for (int i = 0; i < size; i++) {
            System.out.println("index" + i + ",value" + elementData[i]);
        }
    }

    private void ensureCapcacity () {
        int minCapacity = this.size + 1;

        if (minCapacity > elementData.length) {
            int oldCapacity = this.elementData.length;
            //扩容
            int newCapacity = oldCapacity + (oldCapacity >> 1);

            if (newCapacity - minCapacity < 0) {
                newCapacity = minCapacity;
            }
            System.out.println(" capacity is growth");
            this.elementData = Arrays.copyOf(this.elementData, newCapacity);
        }
    }

    private void rangeCheck (int index){
        if (index > elementData.length) {
            throw new IndexOutOfBoundsException("index :" + index + ", is out of range exception");
        }
    }
}