Java集合2——List实现类之ArrayList详解

一、ArrayList简介
以下源码为jdk1.7.8.0**

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问
ArrayList 实现了Cloneable接口，即覆盖了函数clone(）。
ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
ArrayList 是线程不安全的，而 Vector 是线程安全的，即使为保证 List 集合线程安全，也不推荐使用Vector
源码解析

成员变量

    private static final long serialVersionUID = 8683452581122892189L;
 
    /**
     * ArrayList的底层是一个数组
     */
    private transient Object[] elementData;
 
    private int size;
	 构造方法
  public ArrayList(int initialCapacity) {
		super();
       //如果传入的数组大小小于0 会抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	this.elementData = new Object[initialCapacity];
    }
 
       public ArrayList() {
	this(10);     //ArrayList初始化大小为10
    }
 
      public ArrayList(Collection<? extends E> c) {
	elementData = c.toArray();
	size = elementData.length;
	// c.toArray might (incorrectly) not return Object[] (see 6260652)
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

常用方法
1，iterator()：返回了一个实现Iterator接口的对象。可以用这个迭代器对象依次访问集合中的元素

/*
 *Java迭代器是位于两个元素之间，当调用next时，迭代器就越过下一个元素，并返回刚刚越过的那个元素的引
  用。remove方法将会删除上次调用next时返回的元素。
 */
public interface Iterator<E> {
   //判断有没有下一个元素
    boolean hasNext();
    /*通过反复调用next()方法，可以逐个访问集合中的每个元素，但是如果到达了集合的末尾，next方法就会
     抛出一个异常，suoy8i需要一个hasNext方法。*/
    E next();
    //  删除 next方法和remove方法是具有互相依赖性，调用remove方法之前不调用next是不合法的会报异常
    //  如果上次访问之后，集合已经发生了变化也会报异常
    void remove();
    
}

删除 next方法和remove方法是具有互相依赖性，调用remove方法之前不调用next是不合法的会报异常

如果上次访问之后，集合已经发生了变化也会报异常

2，add(Integer element):向集合中添加元素

public boolean add(E e) {
	ensureCapacity(size + 1);  // 扩容
	elementData[size++] = e;
	return true;
    }
 public void ensureCapacity(int minCapacity) {
	modCount++;
	int oldCapacity = elementData.length;
    //如果超过了集合数组初始化大小则进行扩容
	if (minCapacity > oldCapacity) {
	    Object oldData[] = elementData;
    //扩容 为原长度的1.5倍
	    int newCapacity = (oldCapacity * 3)/2 + 1;
    	    if (newCapacity < minCapacity)
		newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
    }

3，add(int index,Integer element):向集合指定位置添加元素

 public void add(int index, E element) {
    //如果下标超过当前元素个数，或者小于0则会报异常
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(
		"Index: "+index+", Size: "+size);
 
	ensureCapacity(size+1);  // 扩容
	System.arraycopy(elementData, index, elementData, index + 1,
			 size - index);
	elementData[index] = element;
	size++;
    }
ArrayList<Integer> arrayList = new ArrayList<Integer>();
		//向集合中添加一个元素
		arrayList.add(12);
		arrayList.add(22);
		arrayList.add(32);
		arrayList.add(42);
		arrayList.add(52);
		//将指定元素插入到指定的地方
		arrayList.add(3, 23);
		//使用迭代器遍历
		Iterator<Integer> iterator = arrayList.iterator();
		while(iterator.hasNext()){
			Integer next = iterator.next();
			//打印出遍历的集合的元素
			System.out.println(next);
		}

如果下标超过当前元素个数，或者小于0则会报异常

4,get(int index):返回一个指定下标的元素的值

public E get(int index) {
	RangeCheck(index);
 
	return (E) elementData[index];
}

通过get方法来对集合进行遍历

5，int size()：返回当前存储在集合中的元素的个数

6，boolean isEmpty(): 如果集合没有元素，返回true

7，boolean contains(Object obj): 如果集合包含了一个与obj相等的对象则返回true

8，boolean containsAll(Colletion<?> other):如果这个集合包含other集合中的所有元素，返回true

9，boolean addAll(Colletion<?> other): 将other集合中的元素添加到这个集合。如果添加成功了返回true

10，boolean remove(Colletion<?> other): 从这个集合中 删除other集合中存在的数

11，void clear():从这个集合中删除所有的元素

12，boolean retainAll(Colletion<?> other):从这个集合中删除所有与other集合中的元素不同的元素

13,Object[]n toArray():返回这个集合的对象数组

14，remove（Object obj）：删除集合中与obj相等的对象

15，T[] toArray(T[] arrayfill) : 返回这个集合的对象数组，如果arrayfill足够大，就将集合中的元素填入这个数组，剩余空间填

null。否则，重新分配一个数组。

二、自定义实现ArrayList

package com.tulun;

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


/**
 * desc: 模拟实现ArrayList的迭代器
 * @user:jr
 * @date:2019/7/11
 */

public class MyArrayList<T> implements Iterable<T>{
    private T[] data;
    private int size;

    public  MyArrayList() {
        this(10);
    }

    public MyArrayList(int capcity) {
        data = (T[])new Object[capcity];
        size = 0;
    }

    private boolean isFull () {
        return size == data.length;
    }

    public void add(T value) {
        if (isFull()) {
            data = Arrays.copyOf(data, data.length<<1+data.length>>1);
        }
        data[size++] = value;
    }

    public T remove(int index){
        if (index < 0 || index > size) {
            return null;
        }

        T oldValue = data[index];
        //数组移动操作
        for (int i= index; i < size; i++) {
            data[i]= data[i+1];
        }
        data[size-1] = null;
        size--;
        return oldValue;
    }



    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < size;
        }

        @Override
        public T next() {
            T value = data[index];
            index++;
            return value;
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(index);
            index--;
        }
    }


    public static void main(String[] args) {
        MyArrayList <Integer> list = new MyArrayList <Integer>();
        list.add(1);
        list.add(2);
        list.add(3);

        Iterator <Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
    }
}