实现ArrayList

public interface MyList<E> {
    public int size();
    public boolean isEmpty();
    public boolean contains(Object o);
    public boolean add(E e);
    public boolean remove(Object o);
    public void clear();
    public E get(int index);
    public E set(int index, E element);
    public void add(int index, E element);
    public E remove(int index);
    public int indexOf(Object o);
    public int lastIndexOf(Object o) ;
    public ListIterator<E> listIterator();
    public ListIterator<E> listIterator(int index);
}

import java.util.*;
import java.util.function.Consumer;

/**
 * @author Xiaoyoou
 * @version 1.0
 * 自定义集合
 * @param <E>
 */
public class MyArrayList<E> implements MyList<E>{
    //集合内部的底层存储的数据结构
    private Object[] elementsObj;
    //集合中数据量的大小
    private int size;
    //用于给定初始容量的大小
    private static final int DEFAULT_CAPACITY = 10;
    //开始未给定集合容量时，新建对象的数组为空，待向其中添加元素时，开始进行扩容操作
    private static final Object[] DEFAULT_EMPTY_ELEMENTS = {};
    //集合的最大容量
    private static final int MAX_CAPACITY = Integer.MAX_VALUE - 8;
    //集合中数组结构的改变次数
    private int modCount;

    /**
     * 无参构造，集合为空
     */
    public MyArrayList() {
        elementsObj = DEFAULT_EMPTY_ELEMENTS;
    }

    /**
     * 有参构造，创建给定大小的集合
     * @param capacity 集合的初始容量
     */
    public MyArrayList(int capacity){
        elementsObj = new Object[capacity];
    }

    /**
     * 获取集合中元素的个数
     * @return 返回元素个数
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 判断集合是否为空
     * @return 集合为空返回true ， 不为空返回false
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 判断集合是否含有给定元素
     * @param o 给定元素
     * @return 集合中返回true ，没有返回false
     * @throws ClassCastException
     * @throws NullPointerException
     */
    @Override
    public boolean contains(Object o) {
        if (indexOf(o) != -1){
            return true;
        }
        return false;

    }

    /**
     * 在集合尾添加一个元素
     * @param e 将e加到集合末尾
     * @return 添加成功返回true ，其他情况抛异常（不允许插入重复或空等）
     * @throws IndexOutOfBoundsException
     * @throws ClassCastException
     * @throws
     */
    @Override
    public boolean add(E e) {
        add(size , e);
        return true;
    }

    /**
     * 确保集合中所需的最小容量，并适当扩容
     * @param minCapacity 最小容量
     */
    private void ensureElementsCapatity(int minCapacity) {
        int newCapacity = minCapacity;
        if (minCapacity < elementsObj.length){
            return;
        }
        newCapacity = minCapacity + (minCapacity >> 1);

        if (minCapacity > newCapacity){
            newCapacity = MAX_CAPACITY;
        }
        grow(newCapacity);

    }

    /**
     * 对集合的容量进行扩容
     * @param minCapacity
     */
    private void grow(int minCapacity) {
        Object[] newElements = new Object[minCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elementsObj[i];
        }
        elementsObj = newElements;
    }

    /**
     * 删除集合中的给定元素的值
     * @param o 给定元素
     * @return 删除成功返回true , 否则返回false
     * @throws NullPointerException
     * @throws IndexOutOfBoundsException
     */
    @Override
    public boolean remove(Object o) {
        int i = indexOf(o);
        if (i != -1 ){
            remove(i);

//            modCount++;
            return true;
        }
        return false;
    }

    /**
     * 将集合中的元素全部清空，size置为0
     */
    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            elementsObj[i] = null;
        }
        size = 0 ;
        modCount++;
    }

    /**
     * 获得索引为index的元素值
     * @param index 给定索引
     * @return 索引对应的值
     * @throws IndexOutOfBoundsException
     * @throws ClassCastException
     *
     */
    @Override
    public E get(int index) {
        checkIndexRemove(index);
        return (E) elementsObj[index];
    }

    /**
     * 将集合索引处的元素设置为给定元素，并返回原来元素
     * @param index 索引
     * @param element 给定元素
     * @return 返回未设置前的元素
     * @throws IndexOutOfBoundsException
     * @throws ClassCastException
     */
    @Override
    public E set(int index, E element) {
        checkIndexRemove(index);
        E e = (E) elementsObj[index];

        elementsObj[index] = element;

        return e;
    }

    /**
     * 在索引位置插入给定元素，并将其他元素后移，size+1
     * @param index 索引
     * @param element 给定元素
     * @throws IndexOutOfBoundsException
     */
    @Override
    public void add(int index, E element) {
        checkIndex(index);

        if (elementsObj == DEFAULT_EMPTY_ELEMENTS){
            elementsObj = new Object[DEFAULT_CAPACITY];
        }
        int minCapacity = size + 1;
        ensureElementsCapatity(minCapacity);
        for (int i = size ; i > index ; i--) {
            elementsObj[i] = elementsObj[i-1];
        }

        elementsObj[index] = element;

        size++;
        modCount++;
//        return true;
    }

    private void checkIndex(int index) {
        if (index < 0 || index > size){
            throw new IndexOutOfBoundsException("index = " + index);
        }
    }

    /**
     * 删除指定索引的元素，集合结构发生改变
     * @param index 指定索引
     * @return 返回删除的元素
     * @throws IndexOutOfBoundsException
     * @throws ClassCastException
     */
    @Override
    public E remove(int index) {
        checkIndexRemove(index);
        E e = (E) elementsObj[index];
        for (int i = index; i < size -1; i++) {
            elementsObj[i] = elementsObj[i + 1];
        }

        size--;
        modCount++;
        return e;
    }

    private void checkIndexRemove(int index) {
        if (index < 0 || index >= size){
            throw new IndexOutOfBoundsException("index = " + index);
        }
    }

    /**
     * 获得给定元素在集合中出现的索引
     * @param o 给定元素
     * @return 集合中有给定元素返回其索引，不含则返回-1
     * @throws NullPointerException
     *
     */
    @Override
    public int indexOf(Object o) {

        if (o == null){
            for (int i = 0; i < size; i++) {
                if (elementsObj[i] == o){
                   return i;
                }

            }
        }else{
            for (int i = 0; i < size; i++) {
                if (o.equals(elementsObj[i]))
                    return i;
            }
        }

        return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        if (o == null){
            for (int i = size - 1; i > 0; i--) {
                if (elementsObj[i] == o){
                    return i;
                }

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

        return -1;
    }

    /**
     * 初始位置为0到的迭代器
     * @return 返回迭代器的实例
     */
    @Override
    public ListIterator<E> listIterator() {
        return new ListItr();
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return new ListItr(index);
    }

    @Override
    public String toString() {
        StringBuffer str = new StringBuffer();

        str.append("[");
        if (size > 0) {
            for (int i = 0; i < size - 1; i++) {
                str.append((String) elementsObj[i] .toString() + ",");
            }
            str.append(elementsObj[size - 1].toString());
        }
        str.append("]");
        return str.toString();
    }


    private  class ListItr implements ListIterator<E>{
        //迭代器遍历数组的游标
        private int cursor ;
        //next或previous上次返回的元素索引
        private int lastRet = -1 ;
        //预期集合结构改变的次数
        private int expectModCount = modCount;
        //无参构造方法
        public ListItr(){

        }

        /**
         * 给定参数的有参构造方法
         * @param index 游标cursor的初始位置
         */
        public ListItr(int index) {
            cursor = index;
        }

        @Override
        public boolean hasNext() {
            return cursor != size;
        }

        /**
         * 如果存在下一个，则返回下一元素的值，lastRet对应最后一次返回的值
         * @return cursor对应的索引值
         * @throws ConcurrentModificationException
         * @throws IndexOutOfBoundsException
         * @throws NoSuchElementException
         * @throws ClassCastException
         */
        @Override
        public E next() {
            checkCountIsChanged();
            int i = cursor;
            if (cursor == size){
                throw new NoSuchElementException("没有下一个元素");
            }
            lastRet = i;
            return (E) elementsObj[cursor++];
        }

        @Override
        public boolean hasPrevious() {
            return cursor != 0;
        }
        /**
         * 如果存在上一个，则返回还是上一元素的值，lastRet对应最后一个上次返回的位置
         * @return cursor-1对应的索引值
         * @throws ConcurrentModificationException
         * @throws IndexOutOfBoundsException
         * @throws NoSuchElementException
         * @throws ClassCastException
         */
        @Override
        public E previous() {
            checkCountIsChanged();
            int i = cursor;
            if (cursor == 0){
                throw new NoSuchElementException("没有上一个元素");
            }
            lastRet = i - 1;
            return (E) elementsObj[--cursor];
        }

        @Override
        public int nextIndex() {
            return cursor;
        }

        @Override
        public int previousIndex() {
            return cursor - 1;
        }

        /**
         * 删除上次next或previous返回索引对应的值
         * @throws ConcurrentModificationException
         * @throws IllegalStateException
         *
         */
        @Override
        public void remove() {
            checkCountIsChanged();
            checkLastRet();
            MyArrayList.this.remove(lastRet);
            expectModCount = modCount;
            cursor = lastRet;
            lastRet = -1;
        }

        private void checkLastRet() {
            if (lastRet < 0){
                throw new IllegalStateException("lastRet  " + lastRet);
            }
        }

        private void checkCountIsChanged() {
            if (expectModCount != modCount){
                throw new ConcurrentModificationException("集合结构被并发修改");
            }
        }

        @Override
        public void set(E e) {
            checkCountIsChanged();

//            checkLastRet();
            MyArrayList.this.set(lastRet , e);

        }

        @Override
        public void add(E e) {

            checkCountIsChanged();
            try{
                //add
                MyArrayList.this.add(cursor , e);
                lastRet = -1;
                cursor ++;
                expectModCount = modCount;
            }catch (ConcurrentModificationException ex){
                throw new ConcurrentModificationException();
            }

        }
    }
}

import java.util.List;
import java.util.ListIterator;

public class MytArrayTest {
    public static void main(String[] args) {

        MyArrayList<String> list = new MyArrayList();
        //向集合中第i个位置插入十个元素
        for (int i = 0; i < 10 ;  i++) {
            list.add(i , String.valueOf(i));
        }
        ListIterator<String> strlist = list.listIterator();

        System.out.println("向集合中插入十个元素" + list);

        list.add("3");
        System.out.println("在末尾插入一个3" + list);

        list.add(1 , "44");
        System.out.println("在索引1的位置插入一个44" + list);

        list.set(0,"00");
        System.out.println("将第0个索引的值置为00" + list);

        String s = list.get(1);
        System.out.println("获取第1个索引位置的元素" + s);

        list.remove("3");
        System.out.println("移除集合中3这个元素之后 " + list);

        boolean contains = list.contains("3");
        System.out.println("判断集合中是否含有元素3 " + contains);
        //开始使用迭代器操作集合
        ListIterator<String> listItr= list.listIterator();
        while (listItr.hasNext()){
            String next = listItr.next();

            if ("9".equals(next)){
                listItr.set("999");
            }
//            String next2 = listItr.next();
            if ("8".equals(next)){
                listItr.remove();
                listItr.add("888");
            }


//            if ("9".equals(next)){
//                list.remove("00");
//            }
        }
        System.out.println("将集合中元素9 ， 置为999 。将集合中元素为8的元素移除并在该位置加上888 " + list);
        System.out.print("向前遍历的结果：");
        while (listItr.hasPrevious()){
            String next = listItr.previous();

            System.out.print(next + " ");
        }
        System.out.println();
        while (listItr.hasNext()) {
            String next = listItr.next();
            //倒数i个元素，删除i-1个元素就不会进入循环
            if ("888".equals(next)) {
                list.remove("999");
                list.remove("00");
            }
        }
        System.out.println("在迭代器迭代过程中用集合方法删除不会抛异常的情况" + list);


//        System.out.println(list);

//        while (strlist.hasNext()){
//            String next = strlist.next();
//            System.out.println(next);
//        }


//        System.out.println(list);

    }
}