我的jdk版本
拆开源码,我们从头道来,不足或误解,请指正
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList是一个泛型类,继承自AbstractList,重写了IndexOf(Object o)等方法,
public int indexOf(Object o) { 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; }
实现了get(index),size()抽象方法
public T get(int index) { rangeCheck(index); return elementData(index); } public int size() { return size; }
实际上,ArrayList底层是这个玩意
transient Object[] elementData;//没有被私有化是为了简化内部类访问
当然还有其他的几个属性:
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private int size;
在ArrayList中有三个构造器,分别为
//初始化容量的构造器 public ArrayList(int initCapacity){ if(initCapacity > 0) this.elementData = new Object[initCapacity]; else if(initCapacity == 0) this.elementData = EMPTY_ELEMENTDATA; else throw new IllegalArgumentException("cant init ArrayList for this initCapacity:"+initCapacity); } /*默认构造器*/ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } /** * 传入继承集合类的实例 * @param c */ public ArrayList(Collection<? extends T> 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; } }
注意的是,默认构造器中,
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
是一个默认的空Object数组
/** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
并没有设置初始值,对于网上一片文章说ArrayList初始化长度为10,我又翻了一下jdk1.7源码
/** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { super(); this.elementData = EMPTY_ELEMENTDATA; }
/** * Shared empty array instance used for empty instances.
* 这里是用final 和 static 修饰的 */ private static final Object[] EMPTY_ELEMENTDATA = {};
也是空数组,所以下面这种构造器最起码不会出现在jdk1.7和jdk1.8中,也就是说两个版本中的实例化ArrayList的时候没有给他设置默认容量
public ArrayList() { this(10); }
那么,什么时候这个空数组才会真正的扩容呢,也就是大家说的容量为10的时候
在源码中,ArrayList提供了这样几个方法,也就是关于ArrayList容量的关键的几个方法
/*方法名直译为:确认容量*/ public void ensureCapacity(int minCapacity) { //最小扩展 int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0: DEFAULT_CAPACITY; if(minCapacity > minExpand) ensureExplicitCapacity(minCapacity); }
上面的这个方法我是看了一阵子,脑回路差点跑偏,换种思路可能会更直观一些
int minExpand = (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? DEFAULT_CAPACITY : 0 ;
我对这个方法的大概理解就是如果elementData是空的,返回一个默认容量(DEFAULT_CAPACITY),长度在上面已经定义好了,是10,如果传入的参数大于这个最小扩展(10),
进入ensureExplicitCapacity()方法,
/*方法名直译为:确认内部容量*/ public void ensureCapacityInternal(int minCapacity) { if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) //取值 10 - 传入最小值之间最大 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); ensureExplicitCapacity(minCapacity); }
判断elementData是否为空数组,是则返回默认长度(10)和传入参数中大的那一个
进入ensureExplicitCapacity()方法,
/* 明确容量*/ public void ensureExplicitCapacity(int minCapacity){ modCount++; //意识到长度溢出时,增长长度 if(minCapacity - elementData.length > 0) grow(minCapacity); };
以上两个方法结束时调用本方法
在ArrayList,LinkedList,HashMap等等的内部实现增,删,改中我们总能看到modCount的身影,modCount字面意思就是修改次数,而拥有这个参数的方法都是线程不安全的
在一个迭代器初始的时候会赋予它调用这个迭代器的对象的mCount,如何在迭代器遍历的过程中,一旦发现这个对象的mcount和迭代器中存储的mcount不一样那就抛异常
这里涉及到了一个机制叫做:
fail-fast机制:
它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时,有可能会产生fail-fast机制。记住是有可能,而不是一定。例如:假设存在两个线程(线程1、线程2),线程1通过Iterator在遍历集合A中的元素,在某个时候线程2修改了集合A的结构(是结构上面的修改,而不是简单的修改集合元素的内容),那么这个时候程序就会抛出 ConcurrentModificationException 异常,从而产生fail-fast机制。
/*有人说int最大减8是尽可能的避免一些错误 */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/** * 长度增长 * @param minCapacity */ public void grow(int minCapacity) { //原数组长度 int oldCapacity = elementData.length; //位运算 右位移1位 int newCapacity = oldCapacity + (oldCapacity >> 1); if(newCapacity - minCapacity < 0) //小于传入长度时 newCapacity = minCapacity; if(newCapacity - MAX_ARRAY_SIZE > 0) //大于上方自定义的最大数组长度 newCapacity = hugeCapacity(minCapacity); elementData = Arrays.copyOf(elementData, newCapacity); };
数组长度在增长时,有位移1并代表增加0.5倍,具体增长的数值,可自行百度java位运算
private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow 超出int整数范围变负数 throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
了解到这几个方法之后,我们来看一下常用的增/删/改/查操作
查:
@SuppressWarnings("unchecked") T elementData(int index){ return (T) elementData[index]; }
//范围检测 public void rangeCheck(int index) { if(index >= size) { throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } }
/*来自父类的抽象方法*/ public T get(int index) { rangeCheck(index);//检测传入参数范围,超过范围数组下标越界 return elementData(index); }
没什么好说的,只是代码抽象化了一点
增
private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
public boolean add(T t) { ensureCapacityInternal(size + 1); elementData[size++] = t; return true; }
public void add(int index, T element) { rangeCheckForAdd(index); ensureCapacityInternal(size + 1); // 增加容量 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++;//??为什么又加了 }
改:
public T set(int index, T element) { rangeCheck(index); T oldValue = elementData(index);//这里的elementData是方法 elementData[index] = element;//这里的elementData是数组 return oldValue; }
//这里的返回值是被替换的元素
删:
public T remove(int index) { rangeCheck(index); modCount++; T oldValue = elementData(index);//方法 int numMoved = size - index -1;//是否超长 if(numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null;//最后一个设置为null 数组 return oldValue; }
到这里ArrayList一些基础内容也讲的差不多了,更为深入的一些机制现在就不提了,以后再深入研究吧
学习是一种态度,不管是jdk源码还是spring或者tomcat源码,抱着借鉴和模仿的心态,努力提高自己.
写代码应该是一件很快乐的事情,过程中也许会有些痛苦,但是往往快乐最后远大于痛苦
不要因为别人一句看这玩意有什么用而放弃自己的追求,不要被外界干扰,自己要坚定