表、栈和队列
表
增强的for循环
List<? extends Integer> l = ...
for (float i : l) {
...
}
same as:（编译器使用迭代器进行改写）
for (Iterator<Integer> i = l.iterator(); i.hasNext();) {
float i0 = (Integer)i.next();
}
这段代码对于任何实现了Iterable接口的对象都可以起作用。
对于数组：
T[] a = Expression;
L1: L2: ... Lm:
for (int i = 0; i < a.length; i++) {
{VariableModifier} TargetType Identifier = a[i];
Statement
}
REF http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html#jls-14.14.2
如果对正在被迭代的集合进行结构上的改变（即对该集合使用add、remove或clear方法），那么迭代器就不再合法（看源码可以发现是通过一个modCount的变量进行判断总共修改次数的），但是，如果迭代器调用自己的remove方法，那么这个迭代器就仍然是合法的。
关于ArrayList和LinkedList的选择
ArrayList底层是用数组实现的，LinkedList则是用双向列表。ArrayList的查找和修改修很快（get和set），都是常数时间（直接修改数组对应索引的值即可），但是都说LinkedList的插入和删除很快，的确，如果是知道结点的位置，插入和删除确实很快，常数时间就可以。但是，在插入前，肯定要先遍历找到结点，这是一个跟N有关的操作。源码中是node(inde index)方法，它是首先判断index的与中间位置的关系，在前半段就通过头结点来进行查找，在后半段就通过尾结点进行查找，确实比ArrayList移动数据快，但也不是常数时间的操作。具体可以查看when-to-use-linkedlist-over-arraylist。
总结一下：
For LinkedList：
- get(int index) is O(n/4) average
- add(E element) is O(1)
- add(int index, E element) is O(n/4) average, but O(1) when index = 0 <— main benefit of LinkedList
- remove(int index) is O(n/4) average
- Iterator.remove() is O(1) <— main benefit of LinkedList
- ListIterator.add(E element) is O(1) <— main benefit of LinkedList
Note: O(n/4) is average, O(1) best case (e.g. index = 0), O(n/2) worst case (middle of list)
For ArrayList
- get(int index) is O(1) <— main benefit of ArrayList
- add(E element) is O(1) amortized, but O(n) worst-case since the array must be resized and copied
- add(int index, E element) is O(n/2) average
- remove(int index) is O(n/2) average
- Iterator.remove() is O(n/2) average
- ListIterator.add(E element) is O(n/2) average
Note: O(n/2) is average, O(1) best case (end of list), O(n) worst case (start of list)
关于ArrayList和LinkedList，修改list立马抛出异常
在AbstactList中有一个int值modCount，对它的注释是：
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
可以看到这个值的作用就是记录那些对list的尺寸有了改动或者对list内部进行了改动导致iterations不能正确执行的修改次数，而在ArrayList和LinkedList的clear()、add()、remove()、sort()等对这个值都进行了modCount++，在Iterator中的next()方法中，会首先执行checkForComodification()方法：
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
所以只要修改了list，立马就会抛出异常。
ArrayList
transient Object[] elementData; // non-private to simplify nested class access
private int size;
一个是放数据的数组，一个是代表当前数据多少的整型。
再贴几个常用的方法的具体实现：
//因此是常数级（添加在末端）
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!!
/*
* Copies an array from the specified source array, beginning at the
* specified position, to the specified position of the destination array.
* @param src the source array.
* @param srcPos starting position in the source array.
* @param dest the destination array.
* @param destPos starting position in the destination data.
* @param length the number of array elements to be copied.
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
*/
System.arraycopy(elementData, index, elementData, index + 1,
size - index);//一个native方法
elementData[index] = element;
size++;
}
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
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;
}
//可以看到是remove掉第一个符合条件的数据
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;
}
LinkedList
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;
}
}
用到的数据结构，可以看到其实是一个双向链表。
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
分别代表头指针和尾指针。
贴一下常用方法的实现：
/**
* 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++;
}
/**
* Inserts element e before non-null Node succ.
*/
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++;
}
/**
* 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;
}
}
/**
* 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;
}
public boolean add(E e) {
linkLast(e);
return true;
}
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
LinkedList还提供了快速获取头尾结点，或者是remove头尾结点的方法。removeFirst、removeLast、getFirst、getLast、addFirst、addLast。。。等等，源码不难，理解了这几点，都可以看懂。
栈
所谓栈，就是一种LIFO（last-in-first-out）表，在Java中是通过继承Vector实现的，主要添加了几个操作让它成为一个栈：
/**
* Pushes an item onto the top of this stack. This has exactly
* the same effect as:
* <blockquote><pre>
* addElement(item)</pre></blockquote>
*
* @param item the item to be pushed onto this stack.
* @return the <code>item</code> argument.
* @see java.util.Vector#addElement
*/
public E push(E item) {
addElement(item);
return item;
}
/**
* Removes the object at the top of this stack and returns that
* object as the value of this function.
*
* @return The object at the top of this stack (the last item
* of the <tt>Vector</tt> object).
* @throws EmptyStackException if this stack is empty.
*/
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
/**
* Looks at the object at the top of this stack without removing it
* from the stack.
*
* @return the object at the top of this stack (the last item
* of the <tt>Vector</tt> object).
* @throws EmptyStackException if this stack is empty.
*/
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
可以看到所有方法都是同步的（addElement()是同步的），方法的实现也都是用的Vector里的方法（好像Vector是是JDK1.0的遗留产物了，是不是不推荐用了？而且继承Vector，那不是很多跟栈不相关的方法也都可以访问到？）。
栈的应用
平衡符号
就是判断左右括号是否可以闭合：
做一个空栈。读入字符直到文件结尾。如果字符是一个开放符号（左边），则将其推入栈中。如果字符是一个封闭符号，则当栈空是报错。否则，将栈元素弹出。如果弹出的符号不是对应的开放符号，则报错。在文件结尾，如果栈非空则报错。
后缀表达式
即逆波兰表示法，所有操作符置于操作数的后面，因此也被称为后缀表示法。逆波兰记法不需要括号来标识操作符的优先级。
解算方法：
当见到一个数时就把它推入栈中，在遇到一个运算符时该运算符就作用于从该栈弹出的两个数上，再将所得到的结果推入栈中。
中缀到后缀的转换
所谓中缀，就是我们正常时候的表达式，转换方式也可以借助栈来实现：
从左到右遍历中缀表达式的每个操作数和操作符。当读到操作数时，立即把它输出，即成为后缀表达式的一部分；若读到操作符，判断该符号与栈顶符号的优先级，若该符号优先级高于栈顶元素，则将该操作符入栈，否则把栈中运算符弹出并加到后缀表达式尾端，直到遇到优先级低于该操作符的栈元素，然后把该操作符压入栈中。如果遇到”(”，直接压入栈中，除非正在处理“)”否则“(”不会从栈中弹出，如果遇到一个”)”，那么就将直到“(”的所有栈元素弹出并加到后缀表达式尾端，但左右括号并不输出。最后，如果读到中缀表达式的尾端，将栈元素依次完全弹出并加到后缀表达式尾端。
例如a+b*c+(d*e+f)*g 可以转成 abc*+de*f+g*+； 1 + (( 2 + 3)* 4 ) – 5可以转成123+4*+5-
方法调用
递归就是不停的将方法压到方法栈中，到达结束条件再一个个弹出来。
队列
所谓队列就是FIFO（first-in-first-out）的表，Java中的LinkedList实现了Queue，可以用Queue接口来窄化LinkedList的方法，Queue queue = new LinkedList()，这样就只能访问Queue中的方法。主要有以下几个方法：
public interface Queue<E> extends Collection<E> {
/**
* Inserts the specified element into this queue if it is possible to do so
* immediately without violating capacity restrictions, returning
* {@code true} upon success and throwing an {@code IllegalStateException}
* if no space is currently available.
*
* @param e the element to add
* @return {@code true} (as specified by {@link Collection#add})
* @throws IllegalStateException if the element cannot be added at this
* time due to capacity restrictions
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null and
* this queue does not permit null elements
* @throws IllegalArgumentException if some property of this element
* prevents it from being added to this queue
*/
boolean add(E e);
/**
* Inserts the specified element into this queue if it is possible to do
* so immediately without violating capacity restrictions.
* When using a capacity-restricted queue, this method is generally
* preferable to {@link #add}, which can fail to insert an element only
* by throwing an exception.
*
* @param e the element to add
* @return {@code true} if the element was added to this queue, else
* {@code false}
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this queue
* @throws NullPointerException if the specified element is null and
* this queue does not permit null elements
* @throws IllegalArgumentException if some property of this element
* prevents it from being added to this queue
*/
boolean offer(E e);
/**
* Retrieves and removes the head of this queue. This method differs
* from {@link #poll poll} only in that it throws an exception if this
* queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
E remove();
/**
* Retrieves and removes the head of this queue,
* or returns {@code null} if this queue is empty.
*
* @return the head of this queue, or {@code null} if this queue is empty
*/
E poll();
/**
* Retrieves, but does not remove, the head of this queue. This method
* differs from {@link #peek peek} only in that it throws an exception
* if this queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
E element();
/**
* Retrieves, but does not remove, the head of this queue,
* or returns {@code null} if this queue is empty.
*
* @return the head of this queue, or {@code null} if this queue is empty
*/
E peek();
}
队列的应用
操作系统的各种数据缓冲区的先进先出管理，应用系统中的各种事件排队管理等等
判断回文
所谓回文就是一个字符序列以中间字符基准两边字符完全相同。解决方法可以将字符逐个分别放入队列和栈中，依次弹出，看是否相等，如果全部相等则是回文。
