Java集合(四)--基于JDK1.8的ArrayList源码解读

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    //默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    //空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //默认空数组,用来和EMPTY_ELEMENTDATA区分什么时候扩容多少
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //存储ArrayList元素的数组缓冲区,ArrayList的容量是此数组缓冲区的长度,添加第一个元素时,*将扩展为DEFAULT_CAPACITY
    transient Object[] elementData;

    //ArrayList的大小,也就是包含的元素数
    private int size;

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {	//初始容量大于0
            this.elementData = new Object[initialCapacity];	//生成一个新的存储数组
        } else if (initialCapacity == 0) {	//初始容量等于0
            this.elementData = EMPTY_ELEMENTDATA;	//设置为空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个包含指定元素的列表
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
}

从上述源码中,我们可以得到以下信息:源码基于JDK1.8

1、implements List<E>, RandomAccess(可以随机访问), Cloneable, java.io.Serializable

2、初始容量10,有看过大佬博客说,默认创建ArrayList的时候,调用默认构造器this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA,此时初始容量为0,而不是10

我的理解:

默认构造器注解:

  Constructs an empty list with an initial capacity of ten

  构造一个初始容量为10的空集合

elementData的注解如下:

  The capacity of the ArrayList is the length of this array buffer. Any empty ArrayList with elementData ==

DEFAULTCAPACITY_EMPTY_ELEMENTDATA will be expanded to DEFAULT_CAPACITY when the first element is added

  第一次添加元素,容量会变成DEFAULT_CAPACITY,也就是初始容量

  所以,只是容量为0,初始容量DEFAULT_CAPACITY是final类型,永远为10,和elementData具体等于什么没关系,容量Capacity才会变

3、并且通过transient Object[] elementData保存数据

add()添加数据

public boolean add(E e) {
	ensureCapacityInternal(size + 1);  //确保容量
	elementData[size++] = e; //在数组尾部添加数据
	return true;
}
private void ensureCapacityInternal(int minCapacity) {
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
	}

	ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
	modCount++; //修改次数+1
	if (minCapacity - elementData.length > 0)  //如果最小容量大于数组的长度,进行扩容
		grow(minCapacity);
}

grow()扩容

private void grow(int minCapacity) {
	int oldCapacity = elementData.length;  //oldCapacity当前数组的长度
	int newCapacity = oldCapacity + (oldCapacity >> 1);  //新容量=oldCapacity*1.5
	if (newCapacity - minCapacity < 0)  //newCapacity < 最小容量,赋值
		newCapacity = minCapacity;
	if (newCapacity - MAX_ARRAY_SIZE > 0)  //大于最大容量,newCapacity赋值为Integer最大值0x7fffffff
		newCapacity = hugeCapacity(minCapacity);
	elementData = Arrays.copyOf(elementData, newCapacity);  //通过Arrays重新生成一个新容量的数组,包含之前数组的数据,赋值原数组
}

remove()删除数据

1、按照数组下标删除

public E remove(int index) {
	rangeCheck(index);  //检查数组是否下标越界

	modCount++;
	E oldValue = elementData(index);  //取出index位置的数据

	int numMoved = size - index - 1;  //
	if (numMoved > 0)
     //将index后面的所有元素,都前移一位 System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; //最后一位置为null return oldValue;  //返回原来的老数据 }

2、按照元素删除

public boolean remove(Object o) {
	if (o == null) {
		for (int index = 0; index < size; index++)
			if (elementData[index] == null) {  //删除第一个null
				fastRemove(index);
				return true;
			}
	} else {
		for (int index = 0; index < size; index++)
			if (o.equals(elementData[index])) {  //删除第一个和object相同的数据
				fastRemove(index);
				return true;
			}
	}
	return false;
}

都是找个第一个和参数匹配的数据,然后执行的代码和第一种方式相同 

复制方法:public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Object src : 原数组

int srcPos : 从元数据的起始位置开始

Object dest : 目标数组

int destPos : 目标数组的开始起始位置

int length : 要copy的数组的长度

set():

public E set(int index, E element) {
	rangeCheck(index);  //检查是否下标越界

	E oldValue = elementData(index);  //获取原值
	elementData[index] = element;  //覆盖原值
	return oldValue;  //返回原值
}

get():

public E get(int index) {
	rangeCheck(index);

	return elementData(index);
}

indexOf():

public int indexOf(Object o) {  //和contain()一样,整体就是遍历是否包含该元素,然后返回下标,如果不包含,返回-1
	if (o == null) {
		for (int i = 0; i < size; i++)
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = 0; i < size; i++)
			if (o.equals(elementData[i]))
				return i;
	}
	return -1;
}

size():和elementData的长度没有关系,指的是实际包含元素的个数

public int size() {
	return size;
}

isEmpty():是否为空

public boolean isEmpty() {
	return size == 0;
}

trimToSize():缩减集合的容量为size,也就是剔除空节点

public void trimToSize() {
	modCount++;
	if (size < elementData.length) {
		elementData = (size == 0)
		  ? EMPTY_ELEMENTDATA
		  : Arrays.copyOf(elementData, size);
	}
}

ArrayList的for循环: 

  for、foreach、Iterator,for效率最好,Iterator效率最差

  只有for循环中调用add()和remove(),才不会发生java.util.ConcurrentModificationException异常,其他两种都会,set()不会出现异常。

  因为add() remove()都会执行modCount++

  ConcurrentModificationException主要为了防止线程并发修改的,因为ArrayList是线程不安全的,做了实现fast-fail机制

public static void main(String[] args) throws IOException {
	ArrayList<String> list = new ArrayList<>();
	list.add("abc");
	list.add("def");
	list.forEach(s -> {
		list.add(s);
		list.remove(s);
	});
	Iterator iterator = list.iterator();
	while (iterator.hasNext()) {
		String s = (String)iterator.next();
		list.remove(iterator.next());
	}
}
输出结果:java.util.ConcurrentModificationException

Itr:

public Iterator<E> iterator() {
	return new Itr();
}

ArrayList实现了自定义的迭代器

private class Itr implements Iterator<E> {
	int cursor;       //游标,下个元素的索引
	int lastRet = -1; //最后一个元素的索引,如果没有返回-1
	int expectedModCount = modCount;//期望修改的次数

	public boolean hasNext() {  //是否有下个元素
		return cursor != size;
	}

	@SuppressWarnings("unchecked")
	public E next() {  //得到下个元素
		checkForComodification();
		int i = cursor;
		if (i >= size)
			throw new NoSuchElementException();
		Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length)
			throw new ConcurrentModificationException();
		cursor = i + 1;  //后移一位
		return (E) elementData[lastRet = i];  
	}

	public void remove() {
		if (lastRet < 0)
			throw new IllegalStateException();
		checkForComodification();

		try {
			ArrayList.this.remove(lastRet);  //删除当前元素
			cursor = lastRet;  //cursor指的是下个元素的索引,由于删除一个元素,所以还是等于当前位置
			lastRet = -1;  
			expectedModCount = modCount;
		} catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		}
	}

	@Override
	@SuppressWarnings("unchecked")
	public void forEachRemaining(Consumer<? super E> consumer) {
		Objects.requireNonNull(consumer);
		final int size = ArrayList.this.size;
		int i = cursor;
		if (i >= size) {
			return;
		}
		final Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length) {
			throw new ConcurrentModificationException();
		}
		while (i != size && modCount == expectedModCount) {
			consumer.accept((E) elementData[i++]);
		}
		// update once at end of iteration to reduce heap write traffic
		cursor = i;
		lastRet = i - 1;
		checkForComodification();
	}

	final void checkForComodification() {  //检查是否发生过并发修改
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
	}
}

ListIterator:

在之前对比Iterator和Iterable有讲过,支持双向遍历,既可以向前,又可以向后

序列化:

  ArrayList本身实现了序列化,transient Object[] elementData,用来保存数据的数组确实用transient修饰的,意味着不能该字段不能实现

序列化,那ArrayList到底如何实现的序列化的呢?

  通过重写writeObject()和readObject(),因为数组中容量Capacity一般都是大于size的,意味着有很多空节点,ArrayList为了节省网络资源

,自定义了序列化,只序列化非空的部分

  如果对序列化不够了解的话,可以参考:Java基础(十一)--Serializable和Externalizable接口实现序列化

到目前为止,我们对ArrayList有了基本的了解:

1、通过数组保存数据,可以随机访问数据,无论是get(i)、add(Object)还是set(int index, E element)效率都是比较高的

2、remove()和add(int index, Object object),都会发生System.arraycopy(),如果index后面的元素比较多的情况下,效率降低很多

3、线程不安全,如果需要保证安全性的话,建议使用CopyOnWriteArrayList

4、初始容量10,发生扩容为原来的1.5倍

 

总结:ArrayList适合顺序插入,按下标访问/修改,不适合删除,按下标插入

posted @ 2019-06-19 18:01  Diamond-Shine  阅读(361)  评论(0编辑  收藏  举报