blockingqueue（先介绍blockingqueue，为什么呢？因为这个不擅长先了解一下）
首先：这个是什么东西
blockingqueue是一个阻塞队列，是一个collection中的一个接口，目的在于解决，多线程之间如何高效的传输数据这个问题。
特点：
当从这个队列中取元素时，它支持这样的操作：如果队列为空，那它就等待队列不为空时，再执行取操作。
当向这个队列中存元素时，它支持这样的操作：如果队列已满，那它就等待队列可用，再向队列中存放元素。（生产者-消费者）
下面方法支持这样的操作，当不同的方法操作不能立即被满足，但是在将来可能被满足：第一个抛出异常，第二个返回一个特殊的值（null或false，取决于哪种操作），第三块会使得当前线程无限期的等待，直到操作可以执行，第四块仅仅给定一个最大等待时间，一旦超过这个时间，就会放弃操作。
| 抛出异常 | 返回特殊值 | 阻塞 | 定时等待 | |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) | put(e) | offer(e, time, unit) |
| 删除 | remove() | poll() | take() | poll(time, unit) |
| 检查 | element() | peek() | 不可用 | 不可用 |
BlockingQueue不接受空值。如果试图用add, put, 或者offer去添加一个null值，则会抛出NullPointerException异常。如果poll 操作失败，则会返回一个空值。
BlockingQueue可能是有界的。在任何一个给时间，它都有一个剩余容量，如果超过这个容量，那么超出的元素将会被阻塞。如果BlockingQueue没有任何内在容量的约束，那么它的剩余容量将会一直是Integer.MAX_VALUE。
为什么可能是有界的呢？这要从它的实现类开始说起。
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}这是blockingqueue实现类之一，在实例化的过程可以传入一个整型变量作为容量，这时候要是某个线程进行put，只要超过了容量，那么当前线程就会被阻塞起来，等待可继续执行的情况发生。（锁的机制后面会说到）
BlockingQueue的实现类主要是设计实现生产者-消费者队列，但是额外支持Collection接口。所以你可以利用remove(x)从队列中删除一个元素。但是这样的操作并不特别高效，仅仅是为了在特定的场景中使用，比如当队列中消息被取消时。
BlockingQueue的实现类是线程安全的。通过内在的锁或者其他的同步机制，所有的队列方法都能够原子性的操作。然而大量的集合操作例如：addAll，containsAll，retainsAll，以及removeAll都不一定会保证原子操作，除非在实现中以其他方式指定。所以当你使用addAll方法将集合c加入到队列中时，可能会抛出一个异常。（这点我不是很理解，因为在源码中未找到）
接下来贴下源码（删了一点注释，注释太多了）
public interface BlockingQueue<E> extends Queue<E> {
//将给定元素设置到队列中，如果设置成功返回true, 否则返回false。如果是往限定了长度的队列中设置值，推荐使用offer()方法。
boolean add(E e);
//将给定的元素设置到队列中，如果设置成功返回true, 否则返回false. e的值不能为空，否则抛出空指针异常。
boolean offer(E e);
//将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞，直到队列中有多余的空间。
void put(E e) throws InterruptedException;
//将给定元素在给定的时间内设置到队列中，如果设置成功返回true, 否则返回false.
boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException;
//从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有值，并且该方法取得了该值。
E take() throws InterruptedException;
//在给定的时间里，从队列中获取值，时间到了直接调用普通的poll方法，为null则直接返回null。
E poll(long timeout, TimeUnit unit)
throws InterruptedException;
//获取队列中剩余的空间。
int remainingCapacity();
//从队列中移除指定的值。
boolean remove(Object o);
//判断队列中是否拥有该值。
public boolean contains(Object o);
//将队列中值，全部移除，并发设置到给定的集合中。
int drainTo(Collection<? super E> c);
//指定最多数量限制将队列中值，全部移除，并发设置到给定的集合中。
int drainTo(Collection<? super E> c, int maxElements);
}
底层数据结构
BlockingQueue的数据结构没有统一的说明：为什么呢？因为它只是一个接口，和List一样。使用什么样的数据结构要看的的实现类采取什么样的方式。一般来说有：数据，堆，链表三种。
1.ArrayBlockingQueue
底层采用的是数组的形式来实现存储，根据其构造方法来看是有界的。下面贴一下该类的构造方法
那好，现在我解释一下为什么它能够解决多线程之间数据传输安全的问题。（我以添加数据为例子来解释）
解释这个之前我们要准备一下基础知识：ReentrantLock 和 Condition:
ReentrantLock(重入锁：公平锁和非公平锁)：这边一句话解释就是，当我要插入的时候，因为该实现类是有界的，所以这时候要是满了，我线程就要被阻塞（等待），那么现在要是空出位置，按照公平锁原则就是等待时间长的线程获取到资源，非公平锁的就是随机分配这个锁。
主要方法：
- lock()获得锁
- lockInterruptibly()获得锁，但优先响应中断
- tryLock()尝试获得锁，成功返回true,否则false，该方法不等待，立即返回
- tryLock(long time,TimeUnit unit)在给定时间内尝试获得锁
- unlock()释放锁
Condition：await()、signal()方法分别对应之前的Object的wait()和notify()
- 和重入锁一起使用
- await()是当前线程等待同时释放锁
- awaitUninterruptibly()不会在等待过程中响应中断
- signal()用于唤醒一个在等待的线程，还有对应的singalAll()方法
我们继续来看一段代码：
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}我们可以看到，构造方法中，根据true或者false，创建公平锁或者非公平锁，同事获取锁的情况来判断读写条件。
好，那么我们最后哎看一下重点，这里以put（）插入方法为例。
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}首先对传入值判空，可能会有人问，为什么是final ReentrantLock lock = this.lock;（这个要扯到JVM内存模型），总之就是速度快，还安全。然后区尝试获得锁。看下面，要是数据满了的话，那就等待。最后写完之后在释放掉锁。
最后来看看删除操作：
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}和上面一样，自行理解。
接着来看链表类型LinkedBlockingQueue
static class Node<E> {
E item;
/**
* One of:
* - the real successor Node
* - this Node, meaning the successor is head.next
* - null, meaning there is no successor (this is the last node)
*/
Node<E> next;
Node(E x) { item = x; }
}
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}它这边的是非公平锁。默认创建非公平锁，只有特定修饰之后才是公平锁
插入的源码
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
/*
* Note that count is used in wait guard even though it is
* not protected by lock. This works because count can
* only decrease at this point (all other puts are shut
* out by lock), and we (or some other waiting put) are
* signalled if it ever changes from capacity. Similarly
* for all other uses of count in other wait guards.
*/
while (count.get() == capacity) {
notFull.await();
}
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
}这里我们看到，插入和上面的另一个是差不多的。但是在在while判断容量的时候，因为一开始，你创建该队列的时候，你使用的是没有赋值大小的构造方法，所以这是capacity是无限大。所以在这一块，线程是不会等待的，即插即用。解释一下为什么是count.get（），因为在多线程里面i++是无法保证原子性的（一个事务一系列操作，要么一次一起做，要么不做）。但是AtomicInteger可以。
删除
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
notEmpty.await();
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}同上
PriorityBlockingQueue：堆结构——其实也是数组类型。PriorityBlockingQueue是一个支持优先级的无界阻塞队列，直到系统资源耗尽。默认情况下元素采用自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。但需要注意的是不能保证同优先级元素的顺序。PriorityBlockingQueue也是基于最小二叉堆实现，使用基于CAS实现的自旋锁来控制队列的动态扩容，保证了扩容操作不会阻塞take操作的执行
一开始创建的时候默认是11的长度，后期会扩容
private static final int DEFAULT_INITIAL_CAPACITY = 11;
public PriorityBlockingQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}private transient volatile int allocationSpinLock;
自旋锁实现扩容关键
扩容这边是一个三元运算，大于64,newcap = oldcap*1.5，小于则newcap=oldcap*2+2；
后面对扩容后的容量进行一个判断，判断就是是否大于最大值上限，会有溢出的情况
private void tryGrow(Object[] array, int oldCap) {
lock.unlock(); // must release and then re-acquire main lock
Object[] newArray = null;
if (allocationSpinLock == 0 &&
UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
0, 1)) {
try {
int newCap = oldCap + ((oldCap < 64) ?
(oldCap + 2) : // grow faster if small
(oldCap >> 1));
if (newCap - MAX_ARRAY_SIZE > 0) { // possible overflow
int minCap = oldCap + 1;
if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
throw new OutOfMemoryError();
newCap = MAX_ARRAY_SIZE;
}
if (newCap > oldCap && queue == array)
newArray = new Object[newCap];
} finally {
allocationSpinLock = 0;
}
}
if (newArray == null) // back off if another thread is allocating
Thread.yield();
lock.lock();
if (newArray != null && queue == array) {
queue = newArray;
System.arraycopy(array, 0, newArray, 0, oldCap);
}
}为什么说他的结构是堆呢，后面详细解答下面几个方法
private void heapify() {
Object[] array = queue;
int n = size;
int half = (n >>> 1) - 1;
Comparator<? super E> cmp = comparator;
if (cmp == null) {
for (int i = half; i >= 0; i--)
siftDownComparable(i, (E) array[i], array, n);
}
else {
for (int i = half; i >= 0; i--)
siftDownUsingComparator(i, (E) array[i], array, n, cmp);
}
}先看入队操作
public void put(E e) {
// 调用offer方法
offer(e); // never need to block
}
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
final ReentrantLock lock = this.lock;
// 进行入队操作时，首先先加锁
lock.lock();
int n, cap;
Object[] array;
// 当队列中的元素数量大于等于数组元素数量时，尝试扩容，具体不再展开
while ((n = size) >= (cap = (array = queue).length))
tryGrow(array, cap);
try {
Comparator<? super E> cmp = comparator;
if (cmp == null)
// 如果我们不传Comparator就使用默认的
siftUpComparable(n, e, array);
else
// 使用自己的Comparator
siftUpUsingComparator(n, e, array, cmp);
// 队列元素数量加1
size = n + 1;
// 当我们入队成功之后，说明队列中已经有元素了，则唤醒被notEmpty阻塞的线程，也就是可以继续执行出队操作了
notEmpty.signal();
} finally {
// 释放锁
lock.unlock();
}
return true;
}
下面我们具体来分析一下自带Comparator的siftUpComparable方法，但是在这之前，我们需要了解一些二叉堆的特性，假如我们有一个数组[1,2,3,4,5,6,7]，那么在二叉堆中是什么样子的呢
二叉堆有一个特性，根据数组的下标，如果节点的下标位置在n处，那么其左孩子节点下标为：2 * n + 1 ，其右孩子节点下标为2 * (n + 1)，其父节点下标为（n - 1） / 2 处，对应到数组的话如下图，我用不同的颜色标注了不同的节点
了解过了二叉堆，我们再来看siftUpComparable方法
// k为队列中元素的数量，x为要入队的元素，array就是我们的队列
private static <T> void siftUpComparable(int k, T x, Object[] array) {
Comparable<? super T> key = (Comparable<? super T>) x;
while (k > 0) {
// 这里拓展一下位运算，<<表示左移移，不分正负数，低位补0
// >>表示右移，如果该数为正，则高位补0，若为负数，则高位补1
// >>>表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0
// 这里的意思等价于parent = (k - 1) / 2，通过上面的二叉堆特性，我们知道了这个parent其实就是k的父节点
int parent = (k - 1) >>> 1;
// 取出队列中间的元素，设置为e
Object e = array[parent];
// 如果要入队的元素大于等于e的话，就直接break掉，最后将这个元素加在数组最后即可
if (key.compareTo((T) e) >= 0)
break;
// 如果上面的if条件不满足，则将e与k的位置交换，然后再跟父节点比大小
array[k] = e;
k = parent;
}
array[k] = key;
}
看完源码之后，我们发现siftUpComparable方法其实就是二叉堆的添加元素的方法实现，所以PriorityBlockingQueue的入队其实就是将元素放入了一个二叉堆中，然后利用二叉堆来进行排序的
接下来就是删除的
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
E result;
try {
// 调用dequeue出队
while ( (result = dequeue()) == null)
// 如果队列中已经没有元素了，那么就调用notEmpty的await方法，阻塞线程继续出队
notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
private E dequeue() {
int n = size - 1;
if (n < 0)
return null;
else {
Object[] array = queue;
E result = (E) array[0];
E x = (E) array[n];
array[n] = null;
Comparator<? super E> cmp = comparator;
if (cmp == null)
// 大部分的逻辑和入队没什么差别，只是这里调用了siftDownComparable方法
siftDownComparable(0, x, array, n);
else
siftDownUsingComparator(0, x, array, n, cmp);
size = n;
return result;
}
}
// 这里跟siftUpComparable方法相比多了一个参数n，代表的是二叉堆的大小
private static <T> void siftDownComparable(int k, T x, Object[] array,
int n) {
if (n > 0) {
Comparable<? super T> key = (Comparable<? super T>)x;
// half = n / 2
int half = n >>> 1; // loop while a non-leaf
while (k < half) {
// child = 2 * k + 1，获取左孩子节点下标
int child = (k << 1) + 1; // assume left child is least
Object c = array[child];
// right = child + 1 = 2 * (k + 1)，获取右孩子节点下标
int right = child + 1;
// 如果右孩子节点下标小于数组长度且左孩子节点的值大于右孩子节点的值，那么将右孩子节点的值赋值给了c
// 这么做是因为二叉堆左右孩子节点的值是不区分谁大谁小的，这一步就得到了两个孩子节点中较小的那个节点的值
if (right < n &&
((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
c = array[child = right];
// 如果要删除的节点小于较小子节点的值，则break掉
if (key.compareTo((T) c) <= 0)
break;
// 否则继续下沉
array[k] = c;
k = child;
}
array[k] = key;
}
}
通过上面出队入队的源码分析，我们知道了PriorityBlockingQueue实现并发安全的机制其实就是在出入队操作时加了一个ReentrantLock，并且使用的是同一个lock，说明出入队操作之间并不能同时执行，只能有一个操作获取锁；然后在出队的时候，如果队列中的元素为空的话，则有一个Condition会将出队的线程阻塞住，阻止继续出队了，只有当入队操作入队成功唤醒了这个Condition才能继续出队
PriorityBlockingQueue用来实现排序功能的原理其实就是底层使用了二叉堆来存储队列中的元素，出入队的操作都会将元素放入二叉堆中进行排序，这样的话，在出队的时候，我们就可以获得排序过的元素了
ArrayList
先看源码变量
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; // non-private to simplify nested class access
private int size;
底层数据结构是数组类型：那么我们可以知道ArrayList的特点是和数组的优势有关系！首先数组具备快速查找的特点，在查找上面的性能数组远远超过链表。
接着我们来分析一下这些变量：首先是DEFAULT_CAPACITY这是ArrayList创建出来的时候的默认长度为10；这里要说一下，ArrayList创建方式不一样的话，这个默认长度还不一定能用到。我们接下来再看一段代码
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}我们可以看出来，如果创建的方式是默认空数组的，数组扩容默认是10。
接下来是DEFAULTCAPACITY_EMPTY_ELEMENTDATA：是用来使用默认构造方法时候返回的空数组。如果第一次添加数据的话那么数组扩容长度为DEFAULT_CAPACITY=10。
EMPTY_ELEMENTDATA：出现在需要用到空数组的地方，其中一处就是使用自定义初始容量构造方法时候如果你指定初始容量为0的时候就会返回。
如果是使用了空数组EMPTY_ELEMENTDATA话，那么一开始第一次添加元素的时候扩容不会返回默认的初始容量DEFAULT_CAPACITY=10。
添加
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
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;
}线程非安全，没有任何锁的机制。
从最基本的List.add()来看，ArrayList是尾插法，同时再插入的时候是自动扩容机制，再看看第二个方法，指定位置插入的时候，会发现多了一个System.arraycopy的方法，这其实是起到一个对数组进行整理的过程，让出位置是index的地方。addAll也基本是这个道理。
来看一下删除的源码
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
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
return oldValue;
}
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;
}
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
}
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}线程安不安全就不分析了，反正就是这个套路，很多线程安全的集合其实就是加锁。
第一个方法：删除完元素之后，然后开始整理数组，数组长度再回退，回退的方式是尾巴置为null
我们看第二个方法：其实就是删除一组数据，怎么说呢？看else里面的操作，是对elementdate数据进行筛查，找到一样的数据，就下放到第三个方法里面去。这里我有一个疑问为什么不是放到第一个方法呢？
第四个方法就是清除所有。
总结：
说了这么多，其实Arraylist的缺点和优点都很明显，第一就是查找方便(因为数据结构是数据的原因)，第二就是线程是不安全的，第三：删除或者是添加的话，需要再次整理数组复杂度是O(n);
LinkedList
LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
LinkedList包含3个全局参数，
size存放当前链表有多少个节点。
first为指向链表的第一个节点的引用。
last为指向链表的最后一个节点的引用。
LinkedList构造方法有两个，一个是无参构造，一个是传入Collection对象的构造。
无参构造为空实现。有参构造传入Collection对象，将对象转为数组，并按遍历顺序将数组首尾相连，全局变量first和last分别指向这个链表的第一个和最后一个。
下面是核心方法：Node是自己的私有类
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}LinkedList方法分析
addFirst/addLast：
public void addFirst(E e) {
linkFirst(e);
}
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++;
} 加入一个新的节点，看方法名就能知道，是在现在的链表的头部加一个节点，既然是头结点，那么头结点的前继必然为null，所以这也是Node<E> newNode = new Node<>(null, e, f);这样写的原因。
之后将first指向了当前链表的头结点，之后对之前的头节点进行了判断，若在插入元素之前头结点为null，则当前加入的元素就是第一个几点，也就是头结点，所以当前的状况就是：头结点=刚刚加入的节点=尾节点。若在插入元素之前头结点不为null，则证明之前的链表是有值的，那么我们只需要把新加入的节点的后继指向原来的头结点，而尾节点则没有发生变化。这样一来，原来的头结点就变成了第二个节点了。达到了我们的目的。
addLast方法在实现上是个addFirst是一致的，这里就不在赘述了。
解释源码太头疼了，我先总结吧
总结：
1：LinkedList的实现是基于双向循环链表，实现的 List和Deque 接口。实现所有可选的列表操作，并允许所有元素（包括null）。
2：LinkedList是非线程安全的，只在单线程下适合使用。
3：这个类的iterator和返回的迭代器listIterator方法是fail-fast ，要注意ConcurrentModificationException 。
4：LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。
5:在查找和删除某元素时，都分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。
6：由于是基于列表的，LinkedList的没有扩容方法！默认加入元素是尾部自动扩容！
7：LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用，如peek 、push、pop等方法。
8：LinkedList是基于链表实现的，因此插入删除效率高，查找效率低！（因为查找需要遍历整个链表）
9：LinkedList和ArrayList一样实现了List接口，但是它执行插入和删除操作时比ArrayList更加高效，因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。
10：LinkedList继承了 AbstractSequentialList抽象类，而不是像 ArrayList和 Vector那样实现 AbstractList，实际上，java类库中只有 LinkedList继承了这个抽象类，正如其名，它提供了对序列的连续访问的抽象
扫一扫
752
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
