《深入理解java虚拟机》这本书大概看了一遍,收获很大,博客就暂时告于段落,不过学习还是继续,下一本书读《java并发编程实战》,配合之前学习的内容,应该可以串联上。
博客新开一个系列,jdk源码系列,读并发和jvm比较枯燥,jdk源码就当做调味品。
从集合类开始,最简单的ArrayList类,我们可以看到ArrayList实现了Serializable接口,并且有一个静态的long型变量serialVersionUID。Serializable接口作用就是使对象可以进行序列化和反序列化,这个接口没有任何方法需要实现。如果一个类没有实现Serializable接口,进行序列化或者反序列时会抛出异常,java.io.NotSerializableException。那么serialVersionUID的作用是什么呢?
我做一个测试,把一个类先进行序列化,写到文件中,再从文件读取反序列化,前后对这个类做一下修改。
情景一:都没有显示的serialVersionUID,是否可以互相序列化与反序列化。
情景二:前后两次类的serialVersionUID不相同,是否可以互相序列化与反序列化。
情景三:前后两次类serialVersionUID相同,但是成员变量不一样,是否可以序列化与反序列化。
经过测试:
情景一可以进行序列化与反序列化。
情景二会抛出异常java.io.InvalidClassException: local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 111。
情景三可以正常进行序列化与反序列化,但是只会反序列化能对应上的成员变量,无法对应的将被忽略。
继续看ArrayList,是一个可以自动扩容的数组,可以保存null,增加、删除、查找时间复杂度都是O(1);
首先第一个成员变量:
private static final int DEFAULT_CAPACITY = 10;
默认数据的大小,在无参构造函数的时候,第一次添加对象的时候初始化数组大小为10;
接下来是两个相近的成员变量:
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
两个成员变量都是在创建时,用来表示空数组的。EMPTY_ELEMENTDATA 是在有参构造函数时使用,DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是在无参构造函数时使用,目的是为了在第一次添加数据时,是否要初始化数据大小为默认值。具体可以看add方法中:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
可以看到ensureCapacityInternal()中:
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
可以看到如果数据是DEFAULTCAPACITY_EMPTY_ELEMENTDATA,会初始化数组大小为默认大小即10和最小容量的最大值。也就是说,如果是无参构造函数,增加对象时最小会初始化数组大小为10。如果是有参数的构造函数,会按照需求来初始化大小。
下一个成员变量就是实际保存数据的数组:
transient Object[] elementData;
最后一个成员变量就是大小:
private int size;
构造函数有三个:
无参构造函数,可以看到初始化的数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA:
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
带参数的两个构造函数:
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
接下来看比较关键的方法:
首先是如何添加一个元素:
最简单的就是在最后一位添加一个元素,首先要先判断是否需要扩容,在最后一个增加元素,并且size加一。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
还可以在指定位置添加元素,首先判断指定的位置是否越界,然后在判断是否需要扩容,再把原数据在index位置后的所有数据向后挪移一位,在index处增加待新增的元素,并且size加一:
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
还可以直接添加一个集合:
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
其时最关键的就是扩容方法,首先是判断是否是无参构造函数新创建的对象,如果是那么扩容的大小为默认大小;再判断是否需要扩容,进行扩容:
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
扩容的方法比较简单,首先是增加1.5倍,然后判断是否达到最小容量要求,否则就设置大小为需求的最小的容量。如果大小超过了默认的最大数组长度Integer.MAX_VALUE - 8,则设置为
Integer.MAX_VALUE大小,
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
查找的方法,分为null和非null两种情况,都是从头遍历数组:
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;
}
还有一个从后遍历查找的方法:
public int lastIndexOf(Object o) {
if (o == 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 (o.equals(elementData[i]))
return i;
}
return -1;
}
第一个是返回数组中第一个匹配的位置,第二个是返回数据中最后一个匹配的位置。
其余的还有set(int index, E element)替换指定位置的数据;
remove(int index)删除指定位置的数据,并把其后的数据向前移动一位;
remove(Object o)删除第一个出现的元素,并把其后数据向前移动一位;
等等很多方法,其中还有一个比较关键的就是迭代器,一般jdk中的集合类都会实现迭代器模式,方便遍历内容。
ArrayList中有两种迭代器,Itr和ListIterator。Itr实现了Iterator接口,并且Itr是ListIterator的父类。
基本的迭代器有hasNext(),next(),remove(),以及jkd1.8中新增加的forEachRemaining(Consumer<? super E> action)。
主要看next()方法中,首先进行了一个判断:
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
这也就说明了,为什么在进行遍历时删除数据,一定要通过迭代器的remove方法,而不能通过ArrayList自带的方法删除。
根本因为是因为ArrayList方法删除数据时,会把其后数据向前移动,导致遍历到重复的数据,甚至会有数组越界的可能。
而迭代器中的remove方法如下:
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
其会先调用ArrayList本身的remove方法后,把当前迭代的游标减一,并重新设置expectedModCount保证下次迭代不会抛出异常,并且设置lastRet为-1,使得remove方法不能连续调用。
未完待续......