ArrayList核心知识总结

ArrayList核心知识总结

本文主要从源码的角度出发,对ArrayList体系进行总结。

一、有⽤过ArrayList吗?它是做什么用的?

ArrayList就是数组列表,底层是数组 Object[] elementData,ArrayList在装载基本数据类型时,实际装载的是对应的包装类。
与ArrayList类似的还有LinkedList,他们俩相⽐:

  • ArrayList:查找和访问元素的速度快,新增、删除的速度慢。线程不安全,使⽤频率⾼。
  • LinkedList:查找和访问元素的速度慢,新增、删除的速度快。
    ArrayList核心知识总结_第1张图片

二、ArrayList线程不安全,为什么还要去用?

实际开发中有以下⼏种场景:

  • 频繁增删:使⽤LinkedList,但是涉及到频繁增删的场景不多
  • 追求线程安全:使⽤Vector。
  • 普通的⽤来查询:使⽤ArrayList,使⽤的场景最多。

根据数据结构的特性,三者难以全包含,只能在相互之间做取舍。

三、ArrayList底层是数组,那是怎么实现不断扩容的?

  • 使⽤⽆参构造创建ArrayList
/**
 * Default initial capacity.
 * 默认的初始化容量
 */
 private static final int DEFAULT_CAPACITY = 10;
 /**
 * 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.
 这个是创建的默认⼤⼩的空数组。EMPTY_ELEMENTDATA⽤于表示当第⼀个数据被添加时该空数组初始化的⼤⼩。
 */
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 /**
 * Constructs an empty list with an initial capacity of ten.
 * 构造⼀个空的List,该List具有10个容量
 */
 public ArrayList() {
 	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }

使⽤ArrayList空参的构造器创建集合时,数组并没有创建。当集合中添加第⼀个元素时,数组被创建,初始化容量为10.

  • 使⽤有参构造创建ArrayList

有参构造创建时,如果指定了容量则会创建出指定容量⼤⼩的数组。如果指定容量为0,则与⽆参构造⼀样。

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param initialCapacity the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 * is negative
 */
 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);
	 }
 }

四、ArrayList(int initialCapacity)会不会初始化数组大小?

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param initialCapacity the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial
capacity
 * is negative
 */
 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);
 	}
 }

会初始化⼤⼩,但如果通过ArrayList的size()⽅法进⾏判断时结果依然为0,因为只有在添加元素时才会对ArrayList的size属性+1

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
 private int size;

五、ArrayList底层是⽤数组实现,但数组长度是有限的,如何实现扩容?

当新增元素,ArrayList放不下该元素时,触发扩容。
扩容的容量将会是原容量的1/2,也就是新容量是旧容量的1.5倍。
确定新容量确定的源码:

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
 private void grow(int minCapacity) {
	 // overflow-conscious code
	 int oldCapacity = elementData.length;
	 //新容量=旧容量+1/2旧容量
	 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);
}

执⾏扩容时使⽤系统类System的数组复制⽅法arraycopy()进⾏扩容。
扩容的源码:

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
	 @SuppressWarnings("unchecked")
	 T[] copy = ((Object)newType == (Object)Object[].class)
	 ? (T[]) new Object[newLength]
	 : (T[]) Array.newInstance(newType.getComponentType(),
	newLength);
	 System.arraycopy(original, 0, copy, 0,
	 Math.min(original.length, newLength));
	 return copy;
 }

六、ArrayList1.7之前和1.7及以后的区别?

1.7之前ArrayList在初始化的时候直接调⽤this(10),初始化容量为10的数组。在1.7及以后,只有第⼀次执⾏add⽅法向集合添加元素时才会创建容量为10的数组。

七、为什么ArrayList增删⽐较慢,增删是如何做的?

  • 没有指定index添加元素
/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return true (as specified by {@link Collection#add})
 */
 public boolean add(E e) {
	 ensureCapacityInternal(size + 1); // Increments modCount!!
	 elementData[size++] = e;
	 return true;
 }
  • 如果指定了index添加元素
/**
 * Inserts the specified element at the specified position in this
 * list. Shifts the element currently at that position (if any) and
 * any subsequent elements to the right (adds one to their
indices).
 *
 * @param index index at which the specified element is to be
inserted
 * @param element element to be inserted
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
 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++;
 }

从源码⾥看到,是将要添加的元素位置index之后的已有元素全部拷⻉到添加到原数组index+1处,然后再把新的数据加⼊。

八、ArrayList插⼊和删除数据⼀定慢吗?

不⼀定,取决于删除的数据离数组末端有多远,如果离末端较近,则性能不⼀定差。

九、ArrayList如何删除数据?

/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
 private void fastRemove(int index) {
	 modCount++;
	 int numMoved = size - index - 1;
	 if (numMoved > 0)
	 	System.arraycopy(elementData, index+1, elementData, index,numMoved);
	 elementData[--size] = null; // clear to let GC do its work
 }

ArrayList删除数据时同样使⽤拷⻉数组的⽅式,将要删除的位置之后的所有元素拷到当前位置,最后再对最后⼀个位置的数据设置为null,交给gc来回收。这种删除,其实就是覆盖,如
果数据量⼤,那么效率很低。

十、ArrayList适合做队列吗?

队列需要遵循先进先出的原则,如果从ArrayList的数组头部⼊队列,数组尾部出队列,那么对于⼊队列时的操作,会涉及⼤数据量的数组拷⻉,⼗分耗性能。队头队尾反⼀反也是⼀样,因此ArrayList不适合做队列。

十一、数组适合做队列吗?

ArrayBlockingQueue环形队列就是⽤数组来实现的。ArrayBlockingQueue的存和取操作的索引是在当索引值等于容量值时,将索引值设置为0实现环形队列的效果,因此在这种情况下,数组适合做队列。

/**
 * Inserts element at current put position, advances, and signals.
 * Call only when holding lock.
 */
 private void enqueue(E x) {
	 // assert lock.getHoldCount() == 1;
	 // assert items[putIndex] == null;
	 final Object[] items = this.items;
	 items[putIndex] = x;
	 if (++putIndex == items.length)
	 	putIndex = 0;
	 count++;
	 notEmpty.signal();
 }
 /**
 * Extracts element at current take position, advances, and
signals.
 * Call only when holding lock.
 */
 private E dequeue() {
	 // assert lock.getHoldCount() == 1;
	 // assert items[takeIndex] != null;
	 final Object[] items = this.items;
	 @SuppressWarnings("unchecked")
	 E x = (E) items[takeIndex];
	 items[takeIndex] = null;
	 if (++takeIndex == items.length)
	 	takeIndex = 0;
	 count--;
	 if (itrs != null)
	 	itrs.elementDequeued();
	 notFull.signal();
	 return x;
}

十二、ArrayList和LinkedList两者的遍历性能孰优孰劣?

ArrayList的遍历性能明显要⽐LinkedList好,因为ArrayList存储的数据在内存中时连续的,CPU内部缓存结构会缓存连续的内存⽚段,可以⼤幅降低读取内存的性能开销。

十三、ArrayList和LinkedList的区别?

ArrayList: 基于动态数组,连续内存存储,适合下标访问(随机访问),扩容机制:因为数组长度固定,超出长度存储数据时需要新建数组,然后将老数组的数据拷贝到新数组,如果不是尾部插入数据还会涉及到元素的移动(往后复制一份,插入新元素),使用尾插法并指定初始容量可以极大提升性能,甚至超过LinkedList(需要创建大量的node对象)。

LinkedList: 基于链表,可以存储在分散的内存中,适合做数据插入及删除操作,不适合查询:需要逐一遍历。遍历LinkedList必须使用iterator不能使用for循环,因为每次for循环体内通过get(i)取得某一元素时需要对list重新进行遍历,性能消耗极大。

另外不要试图使用indexOf等返回元素索引,并利用其进行遍历,使用indexOf对list进行了遍历,当结果为空时会遍历整个列表。

你可能感兴趣的:(java基础知识,java,集合,ArrayList)