那一天,我看着电脑里的一堆笔记陷入沉思,有一个声音在我脑海浮现
“Co Co Da Yo !”,“你走开!”
“想明白生命的意义吗?想真正的活着吗?”,“大哥你走错片场了吧?”
“要不把笔记整理一下,写点文章?”,“试试?”,“干就完事了!奥利给!”
引言
大概在一年半前开始去深入学习Java,看了一些书,看了很多大佬的博客,记了很多笔记。
我本人依旧是一个技术栈很浅的菜鸟,这几天看到@敖丶丙的文章,也想改变一下自己以前枯燥的学习方式,打算先整理自己之前的资料,希望可以和大家共同进步,学无止境。
正文
我忐忑的看着面试官,等待着他的提问。
能简单聊一下ArrayList吗?
心里暗自窃喜,这个简单我都背了20遍了
- ArrayList中的值是可以重复的、且有序的(有序是指插入和取出有序)。
- ArrayList底层通过数组实现,扩容时创建新的数组。
- ArrayList不是线程安全的。
看着我都快憋不住的笑容,面试官微微一笑
可以讲讲创建ArrayList对象时的几种初始化方式吗?
这可难不倒我。
如果通过无参构造器创建ArrayList,那么会在第一次执行add方法时进行扩容,创建大小为10的数组。
通过有参构造器创建ArrayList有两种方式,一种通过传参值在构造方法中创建传参大小的数组,另一种通过传入一个集合,返回一个新的ArrayList。
源码分析
成员变量
private transient Object[] elementData;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private int size;
private static final int DEFAULT_CAPACITY = 10;
构造方法
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) { //initialCapacity大于0初始化固定大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) { //initialCapacity等于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) {
//将集合转换为数组,toArray()返回的值可能不是Object[]类型。
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
//创建新的Object[]数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
Tip:为什么传参是数组的构造器在调用toArray( )后还需要再调用copyOf( )创建一次数组?
因为集合的toArray( )方法不一定会返回Object[ ],举个例子:
Integer [] str = {1,2};
List<Integer> list = Arrays.asList(str);
System.out.println(list.toArray().getClass());
//返回class [Ljava.lang.Integer;
返回的Integer[ ]会使ArrayList即使不使用泛型也无法存放Integer及其子类外的数据.
面试官点了点头,(内心:这小子好像还可以)
你刚刚提到了无参构造器第一次执行add方法时会扩容,你可以详细讲讲扩容流程吗
这啥呀,我抓了抓脑袋。
ArrayList每一次执行add方法会判断当前size值是否大于数组,如果大于则进行扩容,默认情况下扩容1.5倍。
如果扩容1.5倍后数组大小在integer最大值和最大值减8之间,则扩容大小为integer最大值减8。
如果所需数组大小大于integer最大值减8则扩容数组至integer最大值,所需数组大小大于integer最大值则抛出异常。
源码分析
public boolean add(E e) {
ensureCapacityInternal(size + 1); //判断数组是否扩容,size初始化为0
elementData[size++] = e; //为数组赋值
return true;
}
计算当前数组所需的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
/*如果当前数组为空,且minCapacity小于10,则将minCapacity设置为10,
否则输出当前minCapacity*/
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//DEFAULT_CAPACITY值为10
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0) //当数组的下标大于当前数组大小时
grow(minCapacity); //扩容
}
Tip :modCount变量继承自AbstractList类,每次在进行删除和添加时,这个数值都会加1,目的是在迭代时做判断,在迭代时如果删除或添加数据都会抛出异常。
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // 数组默认情况下扩容1.5倍
/*当数组扩容1.5倍后大于Integer.MAX_VALUE,newCapacitity会溢出,值为负数,进入当前判断将
newCapacity 设置为当前数组期望大小*/
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) // 当数组扩容1.5倍后大于MAX_ARRAY_SIZE时,进入 hugeCapacity( )方法。
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity); // 创建一个新的数组,大小为扩容后的大小
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 溢出抛出数组越界异常
throw new OutOfMemoryError();
/*如果所需数组小于MAX_ARRAY_SIZE则设置数组容量为MAX_ARRAY_SIZE
如果所需数组大于MAX_ARRAY_SIZE则设置数组容量为 Integer.MAX_VALUE*/
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
面试官点了点头,脸上的笑容更加灿烂了(内心:我就不信难不倒你!!!)
你有了解过ArrayList对序列化的优化吗
我太难了,QAQ ,还好我早有准备。
ArrayList使用transient 修饰elementData数组,因此在序列化时elementData数组是不会被序列化的。
为什么要这样做呢?因为elementData数组不一定是满的,可能数组的大小是15,但是只有11个数据,我们没有必要序列化整个数组只需要序列化存在的数据即可,这样做可以加快序列化的速度、减小序列化之后的文件大小。
因此ArrayList重写了writeObject和readObject方法,在这两个方法中遍历获取数组中的数据。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
int capacity = calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
嗯 不错 那我们接下来聊聊LinkedList
结束语
其实还有很多地方没聊,比如从线程安全角度去聊,ArrayList for循环,等等这些会在之后对比着其他集合去讲解。
下一篇我会聊聊LinkedList,在聊完集合后我会写一篇集合的面试总结,毕竟集合的面试关键在于集合之间的相互比较。
良师益友(推荐几个大佬)
@敖丶丙 @五月的仓颉 @占小狼