Java笔记（六）列表和队列
列表和队列
一）ArrayList
1.基本原理
ArrayList是一个泛型容器。内部会有一个数组elementData,一般会有预留空间
有一个整数记录实际的元素个数。
private transient Object[] elementData; private int size;
2.迭代
1）foreach:
foreach的背后，编译器会把它转换为：
Iterator<Integer> it = intList.iterator(); while(it.hasNext()){ System.out.println(it.next()); }
只要对象实现了Iterable接口，就可以使用foreach语法。
另外除了iterator()方法，ArrayList还提供了两个返回Iterator的方法：
public ListIterator<E> listIterator() //返回的迭代从0开始 public ListIterator<E> listIterator(int index) //返回的迭代从指定的index开始
ListIterator扩展了Iterator接口：
public interface ListIterator<E> extends Iterator<E> { boolean hasPrevious(); E previous(); int nextIndex(); int previousIndex(); void set(E e); void add(E e); }
2）迭代的陷阱
1）在迭代的时候调用容器的删除方法：
public class Test { public static void main(String[] args) { Integer[] arr = new Integer[] {1, 2, 3, 111, 666, 999}; ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(arr)); remove(list); //java.util.ConcurrentModificationException 并发修改异常 } private static void remove(ArrayList<Integer> list) { for (Integer i : list) { if (i < 100) list.remove(i); } } }
因为迭代器内部会维护一些索引位置相关的数据，要求在迭代的
过程中，容器不能发生结构性变化（添加、删除和插入元素），
否则索引的位置就失效了。解决办法：
private static void remove2(ArrayList<Integer> list) { Iterator<Integer> it = list.iterator(); while (it.hasNext()) { if (it.next() < 100) { it.remove(); } } }
3）迭代的原理
略
4）迭代器的优势
从封装的思路上讲，迭代器封装了各种数据组织方式的迭代操作，提供了简单一致的接口。
3.ArrayList实现的接口
1）Collection
Collection表示一个数据集合，数据间没有位置或顺序的概念。
public interface Collection<E> extends Iterable<E> { int size(); boolean isEmpty(); boolean contains(Object o); Iterator<E> iterator(); Object[] toArray(); <T> T[] toArray(T[] a); boolean add(E e); boolean remove(Object o); boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean equals(Object o); int hashCode(); }
2）List
List表示有顺序或者位置的数据集合，它扩展了Collection。
boolean addAll(int index, Collection<? extends E> c); E get(int index); E set(int index, E element); void add(int index, E element); E remove(int index); int indexOf(Object o); int lastIndexOf(Object o); ListIterator<E> listIterator(); ListIterator<E> listIterator(int index); List<E> subList(int fromIndex, int toIndex);
这些方法都与位置有关。
3）RandomAccess
public interface RandomAccess { }
居然没有定义任何代码，这种没有任何代码的接口称为标记接口，用于声明类的一种属性。
这里实现了RandomAccess接口的类表示可以随机访问，可随机访问就是具备类似数组数组
那样的特性，数据在内存中是连续存放的，根据索引值就可以定位到具体的元素，访问效率高。
有没有声明该接口有什么关系呢？主要用于一些通用的算法代码中，它可以根据这个声明而选择
效率更高的实现。
4.ArrayList的其他方法
构造方法：
public ArrayList(int initialCapacity) //会初始化内部数组的大小，在知道元素长度的情况下，该构造方法可以避免重新分配和复制数组。 public ArrayList(Collection<? extends E> c) //复制一份数据到当前ArrayList中去
两个返回数组的方法：
public Object[] toArray() public <T> T[] toArray(T[] a) //如果参数数组的长度足够，是复制数据到该数组，并返回值，不够就新建一个数组
另外需要注意Arrays中有一个静态方法asList可以将数组转换为List，例如：
Integer[] a = {1,2,3};
List<Integer> list = Arrays.asList(a);
该方法返回的List并不是ArrayList，而是Arrays的一个内部类，在这个内部类实现中，
内部用的数组就是传入的数组，没有拷贝，也不会动态改变大小，所以对数组的修改也会
反应到List中，对List调用add，remove方法会抛出异常。
要用ArrayList的完整方法应该：
List<Integer> list = new ArrayList<Integer>(Arrays.asList(a));
ArrayList还提供了两个方法，可以控制内部使用的数组的大小：
//确保数组的大小至少为minCapacity，如果预知数组较大，可以调用它以减少内存分配次数 public void ensureCapacity(int minCapacity) //该方法会重新分配一个数组，大小刚好为实际内容的长度 //调用该方法可以节省数组占用的空间 public void trimToSize()
5.ArrayList特点分析
作为程序员，就是要理解每种数据结构的特点，根据场合的不同，选择不同的数据结构。
对于ArrayList它的内部是采用动态数组实现的，这就决定了：
1）可以随机访问，按照索引位置进行访问的效率很高，为O(1)
2）除非数组已经排序，否则按照内容查找的效率很低O(N)
3）append元素的效率还行,重新分配和复制数组的开销被平摊了，添加N个元素的效率为O(N)
4）插入和删除元素的效率低，因为要移动元素,效率为O(N)
5）不是线程安全的
二）LinkedList
1.用法
public LinkedList() public LinkedList(Collection<? extends E> c)
除了实现List接口外，LinkedList还实现了队列接口Queue（先进先出，从头部删除元素，尾部添加元素）。
public interface Queue<E> extends Collection<E> { boolean add(E e); //在尾部添加元素,队列满时抛出异常 boolean offer(E e); //在尾部添加元素，队列满时返回false E remove(); //返回头部元素，并从队列中删除，队列为空时抛出异常 E poll(); //返回头部元素，并从队列中删除，队列为空时返回null E element(); //返回头部元素，但不改变队列，队列为空时抛出异常 E peek(); //返回头部元素，但不改变队列,队列为空时返回null }
其实LinkedList实现的是双端队列接口Dueue（双端队列可以当作栈使用，先进后出），
Dueue接口继承自队列接口Queue。Dueue的主要方法：
void push(E e);//入栈，即头部添加元素，栈满抛出异常 E pop();//出栈，返回头部元素，并从栈中删除，栈空抛异常 E peek();//查看栈头部元素，不修改栈，如果栈为空，返回null
所以双端队列即是队列，也是栈。栈只操作头部，队列两端都操作，但尾部
只添加，头部只查看和删除。此外双端队列还包括如下方法：
void addFirst(E e); void addLast(E e); E getFirst(); E getLast(); boolean offerFirst(E e); boolean offerLast(E e); E peekFirst(); E peekLast(); E pollFirst(); E pollLast(); E removeFirst(); E removeLast();
双端队列还有一个迭代器方法：
Iterator<E> descendingIterator();
2.实现原理
1）内部组成
它的内部实现是双向链表，每个元素都是单独存放的，
元素之间通过链链接在一起。为了表示链接关系需要
有一个节点的概念：
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; } }
LinkedList的内部组成就是如下三个实例变量：
transient int size = 0; //链表长度 transient Node<E> first; //表示头节点 transient Node<E> last;//表示尾节点
LinkedList的所有public方法内部都是操作的这三个变量。
2）add方法
add方法代码：
public boolean add (E e) { linkLast(e); return true; }
linkLast方法：
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++; }
由此可以看出，于ArrayList不同LinkedList的内存是按需分配的，
不需要预先分配多余的内存，添加元素只需要分配新元素的空间，然后调节链接就可以了。
3）根据索引访问元素的get方法
public E get(int index) { checkElementIndex(index); return node(index).item; }
//该方法检查索引的有效性 private void checkElementIndex(int index) { if (!isElementIndex(index)) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
private boolean isElementIndex(int index) { return index >= 0 && index < size; }
Node<E> node(int 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; } }
由node方法可以看出，与ArrayList不同用索引获取元素效率很低。
4）根据内容查找
public int indexOf(Object o) { int index = 0; if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; }
效率同样也不高。
5）从中间插入元素
使用方法：
public void add(int index, E element) { checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); }
void linkBefore(E e, Node<E> succ) { // assert succ != null; final Node<E> pred = succ.prev; final Node<E> newNode = new Node<>(pred, e, succ); succ.prev = newNode; if (pred == null) first = newNode; else pred.next = newNode; size++; modCount++; }
可以看出，在中间插入元素，LinkedList需要按需分配内存，修改前驱和后继节点的链接，
虽然效率不高，但ArrayList可能需要分配额外的内存空间，且移动所有元素，相比效率更低。
6）删除元素
public E remove(int index) { checkElementIndex(index); return unlink(node(index)); }
其他略。应该比ArrayList效率高。
3.LinkedList特点总结
1）按需分配，不需要预先分配很多空间
2）不可以随机访问（必须从头或尾顺着链接找），按索引访问效率低。O(N/2)
3）不管队列是否排列，只要是按内容查找，效率都比较低，必须逐个比较。O(N)
4）在两端添加，删除效率很高，为O(1)。
5）在中间插入、删除，要先定位，效率比较低，为O(N),但修改本身效率很高，为O(1)。
三）ArrayDeque
Java容器类中还有一个双端队列的实现类ArrayDeque，它是基于数组实现的。
该容器类主要解决了插入和删除元素效率低的问题。构造方法：
public ArrayDeque() public ArrayDeque(int numElements) //numElement初始分配的最小元素个数 public ArrayDeque(Collection<? extends E> c)
主要实例变量：
private transient E[] elements; private transient int head; private transient int tail;
ArrayDeque的高效来源于head和tail这两个变量，这三个变量构建了循环数组。
1.循环数组
所谓循环数组，是指元素到数组尾后可以接着从数组头开始，
数组的长度、第一个和最后一个元素都与head和tail这两变量相关，具体说：
1）如果head和tail相同，则数组为空，长度为0；
2）如果tail大于head，则第一个元素为elements[head],最后一个元素为elements[tail-1]
长度为tail-head，元素索引为head,到tail-1；
3）如果tail小于head，且为0，则第一个元素为elements[head]，
最后一个为elements[elements.length-1]，元素索引从head到elements.length-1;
4）如果tail小于head，且大于0，则会形成循环，第一个元素为elements[head]，
最后一个元素为elements[tail-1]，元素索引从head到elements.length-1，然后从0到tail-1。
2.构造方法
默认构造方法：
public ArrayDeque() { elements = new Object[16]; }
有参数的：
public ArrayDeque(int numElements) { allocateElements(numElements); }
allocateElements 作用：计算应该分配的数组长度。
最后一个构造函数：
public ArrayDeque(Collection<? extends E> c) { allocateElements(c.size()); addAll(c); }
各种方法实现细节略
3.ArrayDeque特定总结
1）在两端添加、删除元素的效率很高，添加N个效率为O(N);
2）根据元素内容查找和删除的效率比较低为O(N)
3）没有索引的概念，不能进行索引操作。
总之和LinkedList比较，如果只需要使用Deque接口的方法ArrayDeque效率更高。
如果需要经常在中间进行插入和删除或者要使用索引LinkedList更好。
另外，本节介绍的三种容器类型，按内容查找的效率都很低。
浙公网安备 33010602011771号