面试题之---ArrayList实现原理，试题---arraylist
面试题之---ArrayList实现原理，试题---arraylist
单列集合图
1. ArrayList是一个动态数组,实现了List<E>, RandomAccess, Cloneable, java.io.Serializable，并允许包括null在内的所有元素。
1.1,实现了RandomAccess接口标识着其支持随机快速访问,实际上,我们查看RandomAccess源码可以看到,其实里面什么都没有定义.因为ArrayList底层是数组,那么随机快速访问是理所当然的,访问速度O(1).
1.2,现了Cloneable接口,标识着可以它可以被复制.注意,ArrayList里面的clone()复制其实是浅复制
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认长度是10
*/
private static final int DEFAULT_CAPACITY = 10;
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// 默认长度是10
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) { ensureExplicitCapacity(minCapacity); }}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 需要保持的数据大于现有的容量时,开始扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//扩展为原来的1.5倍, oldCapacity>>1表示往右移一个单位,就是除以2的1次方
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果扩为1.5倍还不满足需求，直接扩为你需要的大小
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//将原来的长度,拷贝变成扩展后的大小
elementData = Arrays.copyOf(elementData, newCapacity);
}
2. 底层使用数组实现,默认初始容量为10.当超出后，会自动扩容为原来的1.5倍，即自动扩容机制。
数组的扩容是新建一个大容量（原始数组大小+扩充容量）的数组，然后将原始数组数据拷贝到新数组，然后将新数组作为扩容之后的数组。数组扩容的操作代价很高，我们应该尽量减少这种操作。
3. 该集合是可变长度数组，数组扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量增长大约是其容量的1.5倍，如果扩容一半不够,就将目标size作为扩容后的容量.这种操作的代价很高。采用的是 Arrays.copyOf浅复制,
3.1这里简单说一下什么是浅复制
浅复制:只复制一个对象,但新对象和老对象同是一个地址值,
深复制:复制一个对象,新老对象的地址值也变了.
详情请看(要了解什么是浅复制):点击打开链接https://blog.csdn.net/qq_38859786/article/details/80318977
4. 采用了Fail-Fast机制，面对并发的修改时，迭代器很快就会完全失败，报异常concurrentModificationException(并发修改一次),而不是冒着在将来某个不确定时间发生任意不确定行为的风险
5. remove方法会让下标到数组末尾的元素向前移动一个单位，并把最后一位的值置空，方便GC
6. 数组扩容代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量。
7. ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。
eventbus的订阅方法subscribe()里面,就采用了线程较为安全的CopyOnWriteArrayList集合
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
8,add(E e)方法作用: 添加指定元素到末尾
如果要增加的数据量很大，应该使用ensureCapacity()方法，该方法的作用是预先设置Arraylist的大小，这样可以大大提高初始化速度.
Object obj = new Object();
ArrayList list0 = new ArrayList();
long startTime0 = System.currentTimeMillis();
for(int i=0;i<=N;i++){
list0.add(obj);
}
long endTime0 = System.currentTimeMillis();
Log.e("date", "111没有调用ensureCapacity()方法所用时间：" + (endTime0 - startTime0) + "ms");
ArrayList list1 = new ArrayList();
long startTime1 = System.currentTimeMillis();
list1.ensureCapacity(N);//预先设置list的大小
for(int i=0;i<=N;i++){
list1.add(obj);
}
long endTime1 = System.currentTimeMillis();
Log.e("date", "222调用ensureCapacity()方法所用时间：" + (endTime1 - startTime1) + "ms");
9,如果是添加到数组的指定位置,那么可能会挪动大量的数组元素,并且可能会触发扩容机制;如果是添加到末尾的话,那么只可能触发扩容机制.
10,如果是删除数组指定位置的元素,那么可能会挪动大量的数组元素;如果是删除末尾元素的话,那么代价是最小的. ArrayList里面的删除元素,其实是将该元素置为null.
11,Collection是最顶层的集合,Collection.toArray()在Collection各个子类的源码中使用频繁
12,Arrays.copyOf(U[] original, int newLength, Class<? extends T[]> newType),就是根据class的类型来决定是new还是反射去构造一个泛型数组,同时利用native函数,批量赋值元素至新数组中.
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
//根据class的类型来决定是new还是反射去构造一个泛型数组
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//利用native函数,批量赋值元素至新数组中
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
13, System.arraycopy()复制数组,也是一个高频使用的函数.
@FastNative
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
借鉴:
集合各实现类的底层实现原理
https://blog.csdn.net/qq_25868207/article/details/55259978
CopyOnWriteArrayList详解
https://blog.csdn.net/wjwj1203/article/details/8109000
Java中ArrayList和LinkedList区别
https://blog.csdn.net/wzygis/article/details/20802311
相关文章
- 暂无相关文章
用户点评