问题：
为什么ArrayDeque不实现列表？
长孙鸿波
我现在想要一个数据结构，就像一个有索引的Deque。因此，它应该有O（1）在前面和后面添加和删除元素，以及O（1）基于索引访问元素。这并不难想象一个适合这种情况的设置。
ArrayDeque似乎是一个自然的选择。但是，ArrayDeque不实现List。由于底层数据结构是一个数组，是否有充分的理由不允许索引？
还有，更实用的是，有人知道有哪个图书馆在做我想做的事情吗。据我所知，Apache Commons没有。
共有1个答案
宁飞宇
（编辑，最初的答案基本上是错的）
没有充分的理由说明为什么这个类没有索引。我检查了源代码。它完全按照我上面建议的方式运行。其他一些项目可能更难在List界面中添加。但是，简单的get不是其中之一。
根据使用情况，可以使用给定大小的数组。然后将起始位置设置为中间位置。然后跟踪头部和尾部的变量。迭代项目时，头部向后移动，尾部向前移动，向外扩展。如果你需要一个超出范围的值，你可以对这个值进行模化。长度等于0，-1等于（.length-1），然后继续添加值，直到（（tail-head）
http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/ArrayDeque.java
很确定get非常类似于：
@Override
public E get(int index) {
int i = (head + index) & (elements.length - 1);
return elements[i];
}
看起来他们几乎可以肯定会有。（请参阅源代码链接以获取以下许可信息）。
import java.io.*;
import java.util.AbstractCollection;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
public class ArrayDequeList<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable, List<E>
{
private transient E[] elements;
private transient int head;
private transient int tail;
private static final int MIN_INITIAL_CAPACITY = 8;
private void allocateElements(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
// Find the best power of two to hold elements.
// Tests "<=" because arrays aren't kept full.
if (numElements >= initialCapacity) {
initialCapacity = numElements;
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
if (initialCapacity < 0) // Too many elements, must back off
initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
}
elements = (E[]) new Object[initialCapacity];
}
@Override
public boolean addAll(int index, @NonNull Collection<? extends E> c) {
return false;
}
@Override
public E get(int index) {
int i = (head + index) & (elements.length - 1);
return elements[i];
}
@Override
public E set(int index, E element) {
int i = (head + index) & (elements.length - 1);
E old = elements[i];
elements[i] = element;
return old;
}
@Override
public void add(int index, E element) {
throw new IllegalStateException("This one is hard to do.");
}
@Override
public E remove(int index) {
throw new IllegalStateException("This one is hard to do.");
}
@Override
public int indexOf(Object o) {
throw new IllegalStateException("This one's not that hard but pass..");
}
@Override
public int lastIndexOf(Object o) {
throw new IllegalStateException("This one's not that hard but pass..");
}
@Override
public ListIterator<E> listIterator() {
throw new IllegalStateException("Needs to write a new iterator..");
}
@NonNull
@Override
public ListIterator<E> listIterator(int index) {
throw new IllegalStateException("Needs to write a new iterator..");
}
@NonNull
@Override
public List<E> subList(int fromIndex, int toIndex) {
throw new IllegalStateException("Hm, not sure how this would work.");
}
private void doubleCapacity() {
assert head == tail;
int p = head;
int n = elements.length;
int r = n - p; // number of elements to the right of p
int newCapacity = n << 1;
if (newCapacity < 0)
throw new IllegalStateException("Sorry, deque too big");
Object[] a = new Object[newCapacity];
System.arraycopy(elements, p, a, 0, r);
System.arraycopy(elements, 0, a, r, p);
elements = (E[])a;
head = 0;
tail = n;
}
private <T> T[] copyElements(T[] a) {
if (head < tail) {
System.arraycopy(elements, head, a, 0, size());
} else if (head > tail) {
int headPortionLen = elements.length - head;
System.arraycopy(elements, head, a, 0, headPortionLen);
System.arraycopy(elements, 0, a, headPortionLen, tail);
}
return a;
}
public ArrayDequeList() {
elements = (E[]) new Object[16];
}
public ArrayDequeList(int numElements) {
allocateElements(numElements);
}
public ArrayDequeList(Collection<? extends E> c) {
allocateElements(c.size());
addAll(c);
}
public void addFirst(E e) {
if (e == null)
throw new NullPointerException();
elements[head = (head - 1) & (elements.length - 1)] = e;
if (head == tail)
doubleCapacity();
}
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
elements[tail] = e;
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
doubleCapacity();
}
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
public E removeFirst() {
E x = pollFirst();
if (x == null)
throw new NoSuchElementException();
return x;
}
public E removeLast() {
E x = pollLast();
if (x == null)
throw new NoSuchElementException();
return x;
}
public E pollFirst() {
int h = head;
E result = elements[h]; // Element is null if deque empty
if (result == null)
return null;
elements[h] = null; // Must null out slot
head = (h + 1) & (elements.length - 1);
return result;
}
public E pollLast() {
int t = (tail - 1) & (elements.length - 1);
E result = elements[t];
if (result == null)
return null;
elements[t] = null;
tail = t;
return result;
}
public E getFirst() {
E x = elements[head];
if (x == null)
throw new NoSuchElementException();
return x;
}
public E getLast() {
E x = elements[(tail - 1) & (elements.length - 1)];
if (x == null)
throw new NoSuchElementException();
return x;
}
public E peekFirst() {
return elements[head]; // elements[head] is null if deque empty
}
public E peekLast() {
return elements[(tail - 1) & (elements.length - 1)];
}
public boolean removeFirstOccurrence(Object o) {
if (o == null)
return false;
int mask = elements.length - 1;
int i = head;
E x;
while ( (x = elements[i]) != null) {
if (o.equals(x)) {
delete(i);
return true;
}
i = (i + 1) & mask;
}
return false;
}
public boolean removeLastOccurrence(Object o) {
if (o == null)
return false;
int mask = elements.length - 1;
int i = (tail - 1) & mask;
E x;
while ( (x = elements[i]) != null) {
if (o.equals(x)) {
delete(i);
return true;
}
i = (i - 1) & mask;
}
return false;
}
public boolean add(E e) {
addLast(e);
return true;
}
public boolean offer(E e) {
return offerLast(e);
}
public E remove() {
return removeFirst();
}
public E poll() {
return pollFirst();
}
public E element() {
return getFirst();
}
public E peek() {
return peekFirst();
}
public void push(E e) {
addFirst(e);
}
public E pop() {
return removeFirst();
}
private void checkInvariants() {
assert elements[tail] == null;
assert head == tail ? elements[head] == null :
(elements[head] != null &&
elements[(tail - 1) & (elements.length - 1)] != null);
assert elements[(head - 1) & (elements.length - 1)] == null;
}
private boolean delete(int i) {
checkInvariants();
final E[] elements = this.elements;
final int mask = elements.length - 1;
final int h = head;
final int t = tail;
final int front = (i - h) & mask;
final int back = (t - i) & mask;
// Invariant: head <= i < tail mod circularity
if (front >= ((t - h) & mask))
throw new ConcurrentModificationException();
// Optimize for least element motion
if (front < back) {
if (h <= i) {
System.arraycopy(elements, h, elements, h + 1, front);
} else { // Wrap around
System.arraycopy(elements, 0, elements, 1, i);
elements[0] = elements[mask];
System.arraycopy(elements, h, elements, h + 1, mask - h);
}
elements[h] = null;
head = (h + 1) & mask;
return false;
} else {
if (i < t) { // Copy the null tail as well
System.arraycopy(elements, i + 1, elements, i, back);
tail = t - 1;
} else { // Wrap around
System.arraycopy(elements, i + 1, elements, i, mask - i);
elements[mask] = elements[0];
System.arraycopy(elements, 1, elements, 0, t);
tail = (t - 1) & mask;
}
return true;
}
}
public int size() {
return (tail - head) & (elements.length - 1);
}
public boolean isEmpty() {
return head == tail;
}
public Iterator<E> iterator() {
return new DeqIterator();
}
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
private class DeqIterator implements Iterator<E> {
private int cursor = head;
private int fence = tail;
private int lastRet = -1;
public boolean hasNext() {
return cursor != fence;
}
public E next() {
if (cursor == fence)
throw new NoSuchElementException();
E result = elements[cursor];
// This check doesn't catch all possible comodifications,
// but does catch the ones that corrupt traversal
if (tail != fence || result == null)
throw new ConcurrentModificationException();
lastRet = cursor;
cursor = (cursor + 1) & (elements.length - 1);
return result;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
if (delete(lastRet)) { // if left-shifted, undo increment in next()
cursor = (cursor - 1) & (elements.length - 1);
fence = tail;
}
lastRet = -1;
}
}
private class DescendingIterator implements Iterator<E> {
private int cursor = tail;
private int fence = head;
private int lastRet = -1;
public boolean hasNext() {
return cursor != fence;
}
public E next() {
if (cursor == fence)
throw new NoSuchElementException();
cursor = (cursor - 1) & (elements.length - 1);
E result = elements[cursor];
if (head != fence || result == null)
throw new ConcurrentModificationException();
lastRet = cursor;
return result;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
if (!delete(lastRet)) {
cursor = (cursor + 1) & (elements.length - 1);
fence = head;
}
lastRet = -1;
}
}
public boolean contains(Object o) {
if (o == null)
return false;
int mask = elements.length - 1;
int i = head;
E x;
while ( (x = elements[i]) != null) {
if (o.equals(x))
return true;
i = (i + 1) & mask;
}
return false;
}
public boolean remove(Object o) {
return removeFirstOccurrence(o);
}
public void clear() {
int h = head;
int t = tail;
if (h != t) { // clear all cells
head = tail = 0;
int i = h;
int mask = elements.length - 1;
do {
elements[i] = null;
i = (i + 1) & mask;
} while (i != t);
}
}
public Object[] toArray() {
return copyElements(new Object[size()]);
}
public <T> T[] toArray(T[] a) {
int size = size();
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
copyElements(a);
if (a.length > size)
a[size] = null;
return a;
}
public ArrayDequeList<E> clone() {
try {
ArrayDequeList<E> result = (ArrayDequeList<E>) super.clone();
result.elements = Arrays.copyOf(elements, elements.length);
return result;
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
private static final long serialVersionUID = 2340785798034038923L;
private void writeObject(ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
// Write out size
s.writeInt(size());
// Write out elements in order.
int mask = elements.length - 1;
for (int i = head; i != tail; i = (i + 1) & mask)
s.writeObject(elements[i]);
}
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
// Read in size and allocate array
int size = s.readInt();
allocateElements(size);
head = 0;
tail = size;
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
elements[i] = (E)s.readObject();
}
}
类似资料：
-
问题内容： 我试图理解 为什么Java的ArrayDeque比Java的LinkedList更好， 因为它们都实现了Deque接口。 我几乎看不到有人在他们的代码中使用ArrayDeque。如果有人对ArrayDeque的实现方式有了更多的了解，那将是有帮助的。 如果我理解它，我会更自信地使用它。对于JDK实现管理头和尾引用的方式，我不清楚。 问题答案： 链接结构可能是最糟糕的结构，要在每个元素上
-
问题内容： 在中，我们具有接口List和类： 并扩展AbstractList和 我的问题：为什么ArrayList有该implements List条款？ 如果，我们不能说吗？ 问题答案： 是。可以省略。但是，这是一个立即可见List。否则，将需要额外单击代码/文档。我认为这就是原因-清晰。 并补充的评论-这是为了展示该工具。总体而言，这只是为了方便起见，并减少了List实现之间的代码重复。
-
问题内容： 你知道吗 ： 将输出： 这是由于（继承自）未覆盖的事实引起的。 您知道为什么会这样吗？ 问题答案： 根据的合同，没有针对s 的通用equals（）方法，因此无法提供一个。 请注意，它既不是Set也不是List，因此既不是数量也不是它不支持的原因。
-
问题内容： 有谁知道为什么 不执行？这意味着您无法对排序，这在我看来有点奇怪。 讨论后更新： 感谢所有有用的回复。最后，我对该主题进行了更多研究。 为什么java.lang.Number不实现Comparable的最简单解释源于可变性问题。 对于位的检讨，是抽象的超类型的，，，，，，，，和。在该列表中，并以没有实现。 深入研究，我发现在可变类型上实现不是一种好习惯，因为在比较期间或之后对象可能会更
-
问题内容： 根据Java文档中的Serializability： 通过实现java.io.Serializable接口的类，可以启用类的可序列化性。未实现此接口的类将不会对其状态进行序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义 为什么对象尚未实现？我们不希望可序列化的成员可以设为。为什么要阻止默认的Serializability？