本文详细介绍了ArrayList和LinkedList两种Java集合实现的区别。ArrayList基于动态数组，适合随机访问但插入删除效率较低；LinkedList采用双向链表，插入删除高效但遍历效率低。在实际使用中，应根据操作特性和性能需求选择合适的集合类型。
目录
List
• ArrayList底层就是一个长度可以动态增长的Object数组；
ArrayList
ArrayList基础属性
/**
* Default initial capacity.默认数组大小
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.空对象1
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 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.空对象2
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.存储ArrayList元素的数组
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
构造方法
/**
* 构造指定初始容量的List
*/
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);
}
}
/**
*当不指定初始容量时，默认大小为10.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构建指定集合初始元素的list
*/
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;
}
}
Add方法
以最基本的Add为例说明ArrayList扩容机制：
/**
* 追加一个元素至ArrayList末尾
*此时，所需最小容量为当前数组大小+1
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
首先调用ensureCapacityInternal去计算容量，如果当前ArrayList为默认容量元素数组（构建时未指定初始容量），则取默认容量和最小容量size+1的最大值。否则，返回size+1；
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
调用ensureExplicitCapacity判断是否需要扩容，如果需要则调用grow方法扩容。否则，直接将元素放入elementData末尾。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
扩容为原长度的1.5倍，若扩容后的大小仍不满足最小容量需求，则按扩容机制，newCapacity = minCapacity;若扩容后容量大于最大数组容量，则hugeCapacity判断是否内存溢出，是则直接抛错，否，则将容量扩大为MAX_ARRAY_SIZE（最大值-8）或者Integer的最大值。最后将内容copy到扩容后的数组内。
/**
* 扩容
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 此if何时为true?
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
Get方法
直接返回数组目标下标元素。
public E get(int index) {
rangeCheck(index);
checkForComodification();
return ArrayList.this.elementData(offset + index);
}
Remove方法
ArrayList的删除元素是用复制的方式，将第一个出现的目标元素之后的全部元素整体移动（复制）一格。然后将数组末尾的元素置为null；
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
fastRemove
/*
* 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
}
LinkedList
底层是一个双向链表。
基础属性
transient int size = 0;
/**
* 头结点
*/
transient Node<E> first;
/**
* 尾结点
*/
transient Node<E> last;
node类
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
构造方法
/**
* 构造空链表
*/
public LinkedList() {
}
/**
* 构造链表并赋值初始元素
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
Add方法
/**
* 追加元素至链表末尾
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 追加元素至链表头部
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 追加元素至链表末尾，效果同add
*
* <p>This method is equivalent to {@link #add}.
*
* @param e the element to add
*/
public void addLast(E e) {
linkLast(e);
}
linkedLast、linkFirst
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
/**
* Links e as first element.
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
Get方法
需要遍历双向链表。
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
/**
* Returns the (non-null) Node at the specified element index.
*/
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
Remove方法
删除linkedList中第一个出现的目标元素，若目标元素为null，则删除第一个item为null的元素。
/**
* 删除linkedList中第一个出现的目标元素
*/
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
unlinked
/**
* Unlinks non-null node x.
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
总结
ArrayList
对应数据结构中的顺序表
• 在内存中分配连续的空间，实现了长度可变的数组。
• 优点：遍历元素和随机访问元素的效率比较高。
• 缺点：添加和删除需大量移动元素效率低，按照内容查询效率低。
LinkedList
对应数据结构中的双向链表
• 采用双向链表存储方式。
• 缺点：遍历和随机访问元素效率低下
• 优点：插入、删除元素效率比较高（但是前提也是必须先低效率查询才可。如果插入删除发生在头尾可以减少查询次数）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
