public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
// list.iterator() 重置迭代器，可重复
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer next = iterator.next();
System.out.println(next);
}
}
}
3. Collection 接口遍历元素方式2，for循环增强
增强 for 循环，可以代替 iterator 迭代器，特点：增强 for 本质就是迭代器。只能用于遍历集合或数组。
java复制代码
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
for (Integer e : list) {
System.out.println(e);
}
}
}
public class Vector_<E> {
protected Object[] elementData;
protected int capacityIncrement;
protected transient int modCount = 0;
protected int elementCount;
public Vector_() {
this(10);
}
public Vector_(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector_(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0){
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
// 初始化数组
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
// 判断是否扩容
if (minCapacity - elementData.length > 0){
grow(minCapacity);
}
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// newCapacity = oldCapacity + oldCapacity
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0){
newCapacity = minCapacity;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
六、LinkedList（P515）
1. LinkedList 说明
（1）LinkedList 底层实现了双向链表和双端队列特点。
（2）可以添加任意元素（元素可以重复），包括 null。
（3）线程不安全，没有实现同步。
2. LinkedList 的底层操作机制
（1）LinkedList 底层维护了一个双向链表。
（2）LinkedList 中维护了两个属性 first 和 last 分别指向首节点和尾节点。
（3）每个节点（Node对象），里面又维护了 prev 、next 、item 三个属性，其中通过 prev 指向前一个，通过 next 指向后一个节点。最终实现双向链表。
（4）所以 LinkedList 的元素的添加和删除，不是通过数组完成的，相对来说 效率较高。
3. LinkedList 源码 解读（P516）
java复制代码
public class LinkedList_<E> {
transient int size = 0;
protected transient int modCount = 0;
transient Node<E> first;
transient Node<E> last;
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 boolean add(E e) {
linkLast(e);
return true;
}
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++;
}
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null) {
throw new NoSuchElementException();
}
return unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null) {
last = null;
} else {
next.prev = null;
}
size--;
modCount++;
return element;
}
}
