手动实现ArrayList

温馨提示： 如果觉得对你有那么一点帮助，请帮我在评论区祝我喜欢的女孩能够找到幸福：晓儿，祝你幸福！

package com.xiao.mycollection;

import java.util.Arrays;
import java.util.Iterator;

public class MyArrayList implements Iterable{

	private Object[] elementData;
	/**
	 * 列表的长度(列表中的元素个数)
	 */
	private int size;
	
	public MyArrayList() {
		this(10);
	}
	
	public MyArrayList(int initialCapacity) {
		if (initialCapacity < 0) {
			throw new IllegalArgumentException("初始化参数:"+ initialCapacity);  //如果初始化参数小于零，抛出不合法参数异常
		}
		elementData = new Object[initialCapacity];
	}
	
	//返回列表中的元素个数
	public int size() {
		return size;
	}
	
	//判断列表中是否为空
	public boolean isEmpty() {
        return size == 0;
    }
	
	//判断列表中是否包含某元素
	public boolean contains(Object obj) {
        return indexOf(obj) >= 0;
    }
	
	//查找某个元素在ArrayList中第一次出现的位置(返回elementData数组中值相同的首个元素的下标)
	public int indexOf(Object obj) {
		//ArrayList中可以存放null元素,indexof中比较方法是equals而equals是比较元素的值，因此必须对null单独查找。如果未找到该元素则返回-1 。
		if (obj == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (obj.equals(elementData[i]))
                    return i;
        }
		//如果没有找到对应的元素返回-1
        return -1;
	}
	
	//查找某个元素在ArrayList中最后出现的位置(elementData数组从后往前找到第一个跟要查找值相同的元素的下标)
	public int lastIndexOf(Object obj) {
        if (obj == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (obj.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
	
	//返回ArrayList中指定下标为index的元素
	public Object get(int index) {
		rangeCheck(index);

		return elementData[index];
    }
	
	//将element放入列表下标为index的位置，覆盖原来的元素，返回值为被覆盖的元素
	public Object set(int index, Object element) {
		rangeCheck(index);
		
		Object oldValue = elementData[index];
		elementData[index] = element;
		return oldValue;
	}
	
	//在列表末尾添加元素
	public boolean add(Object obj) {
        ensureCapacityInternal(size + 1);  // 加入元素前检查数组的容量是否足够
        elementData[size++] = obj;
        return true;
    }
	
	//在列表指定位置插入元素
	public void add(int index, Object obj) {
		rangeCheckForAdd(index);  //用于检查index是否越界
		
		ensureCapacityInternal(size + 1);  //检查elementData的长度是否足够，不够扩容
		
		for (int i = size; i > index; i--) {
			elementData[i] = elementData[i - 1];  //数组元素后移
		}
		elementData[index] = obj;
	}
	
	//删除指定位置的元素
	public Object remove(int index) {
		rangeCheck(index); //不用判断index是否小于零，因为在下一步取出该位置元素时，系统会自动检测
		
		Object oldValue = elementData[index];
		
		for (int i = index; i < size; i++)
			elementData[i] = elementData[i + 1];  //将index之后的元素前移
		
		elementData[--size] = null;  // 将数组最后一位置空，方便GC回收
		
		return oldValue;
	}
	
	public boolean remove(Object obj) {
		if (obj == null) {
			for (int i = 0; i < size; i++)
				if (elementData[i] == null) {
					fastRemove(i);
					return true;
				}
		} else {
			for (int i = 0; i < size; i++)
				if (obj.equals(elementData[i])) {
					fastRemove(i);
					return true;
				}
		}
		return false;
	}
	
	/**
	 * 省去remove方法中的边界检查和返回值
	 */
	private void fastRemove(int index) {
		for (int i = index; i < size; i++)
			elementData[i] = elementData[i + 1];
		
		elementData[--size] = null;
	}
	
	public void clear() {
		
		for (int i = 0; i < size; i++) {
			elementData[i] = null;
		}
		size = 0;
	}
	
	private void ensureCapacityInternal(int minCapacity) {
		if (minCapacity > elementData.length) {
			grow(minCapacity);
		}
	}
	
	//数组扩容
	private void grow(int minCapacity) {
		// overflow-conscious code
        int oldCapacity = elementData.length;
        将数组的长度增加原来数组的一半
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果扩充一半后仍然不够，则 newCapacity = minCapacity;minCapacity为实际元素的个数。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 将elementData中的元素copy到新数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
	}
	 
	private void rangeCheck(int index) {
		//index>=size要检查的原因:有可能数组的大小大于index，然而有效的元素数量<index这时不抛异常就会返回无效值(null,因为null是无效位置的默认值)。
		//这里值检查index >= size的情况，因为index<0时系统会自动抛出异常(因为数组的下标不能取负值，系统会自动报错)，所以并未检查index<0的情况。
		if (index >= size)
			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}
	
	private void rangeCheckForAdd(int index) {
		if (index > size || index < 0) {
			throw new IllegalArgumentException(outOfBoundsMsg(index));
		}
	}
	
	@Override
	public Iterator iterator() {
		return new Itr();
	}
	
	private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
	
	
	private class Itr implements Iterator {

		int cursor;       // index of next element to return
		
		Itr() {}
		
		@Override
		public boolean hasNext() {
			 return cursor != size;
		}

		@Override
		public Object next() {
			return  elementData[cursor++];
		}
	}
	
	public static void main(String[] args) {
		MyArrayList list = new MyArrayList();
		System.out.println(list.size());
		list.add("aa");
		list.add("bbb");
		list.add("cc");
		list.set(1, "bb");
		Iterator it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
			
		}
		
		//foreach方法只能遍历数组和Iterable的实例
		for (Object obj : list) {
			System.out.println(obj);
		}
	}

解释两个问题：

    1、为什么在添加元素和删除元素时使用的是不同的索引检查方法?

        这是应为在删除元素时会有一个取出elementData数组元素的过程，系统会自动对索引的边界进行判断。那肯定有人要问为什么要都要判断上界，因为我们需要判断的是数组的有效长度而不是实际长度，因为如果不进行判断，可能会存在index正好大于有效元素个数但小于数组长度，这时会取出null这个默认值，而不是报错。关于有效长度和实际长度的区别在第二个问题讨论。

    2、有效长度（size）和实际长度（elementData.length）的区别:

    有效长度指的是数组中实际存储的有效元素个数，实际长度是我们在初始化或扩充数组长度时确定的数组容量。当添加元素的过程中，有效元素个数(size)等于数组容量(length)时，再添加就会造成数据溢出，所以需要扩容。