public interface Iterable<T> {
  ...
}

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("123");
    list.add("456");
    Iterator<String> iterator = list.iterator();
    //方式一：直接使用next()单个遍历
    //System.out.println(iterator.next());
    //System.out.println(iterator.next());
    //方式二：通过hasNext()与next()配合使用(确定Iterator中的个数并输出)
    //while(iterator.hasNext()){
    //    System.out.println(iterator.next());
    //}
    //方式三：通过原本集合的size()获取到指定个数，接着输出即可
    //        for(int i=0;i<list.size();i++){
    //            System.out.println(iterator.next());
    //        }
    //方式四：通过foreach遍历
    for (String s : list) {
        System.out.println(s);
    }
}

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("123");
    list.add("456");
    Iterator<String> iterator = list.iterator();
    //删除所有元素
    while(iterator.hasNext()){
        iterator.next();
        //需要在next()之后调用
        iterator.remove();
    }
    System.out.println(list);//[]
}

public Iterator<E> iterator() {
    //实际上返回的是自己的内部类Itr
    return new Itr();
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    //数据都存储在这个数组之中
    transient Object[] elementData;
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //初始构造
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //返回迭代器
    public Iterator<E> iterator() {
        return new Itr();
    }
    //内部类继承了Iterator接口
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
        Itr() {}
        //调用这个方法实际上就是判断当前下标是否已经到达最后一个位置了，size指当前存放对象数组中的数量
        public boolean hasNext() {
            return cursor != size;
        }
        //主要就是返回在elementData数组的lastRet位置的数据
        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;//首次为0
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;//接着加+1，表示下一次要读取的位置
            return (E) elementData[lastRet = i];//这里实际上就是之前cursor的位置数
        }
        //移除lastRet位置的对象
        public void remove() {
            //因为初始lastRet或者执行一次remove()之后为-1，所以之前说单独调用remove()就会报错
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                //实际上就是调用了ArrayList本身的remove()方法
                ArrayList.this.remove(lastRet);
                cursor = lastRet;//倒退1
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
       ...
    }
}

//Arrays工具类中的方法
@SafeVarargs
@SuppressWarnings("varargs")
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

//该类是Arrays工具类的内部类，同样也是继承了AbstractList，所以也算是List的子类
private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;
    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }
    ...
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    transient Object[] elementData;
    //无参构造器：并没有开辟指定容量大小，直接elementData = {};
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //首次add()方法会开辟10个容量大小的数组，接着进行添加操作；超过容量大小重新扩容创建数组
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //这里给出一个关键的方法(在add()中调用)，其中就可以看到扩容为1.5倍
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//>>1是位运算相当于除以2，所以扩容为1+0.5=1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

private static class Node<E> {
    E item;
    Node<E> next;//记录当前Node节点的前一个元素
    Node<E> prev;//记录当前Node节点的后一个元素
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
    //无参构造器：没有做任何事
    public LinkedList() {
    }
    //add添加方法：直接调用linkLast()方法
    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;//若是第一次创建链表，该Node节点为第一个节点
        else
            l.next = newNode;//不是第一个节点，那么将刚创建的节点放置到最后一个Node节点的Next()接收
        size++;
        modCount++;
    }
    ...
}

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    protected Object[] elementData;
    //无参构造器默认创建大小为10的数组
    public Vector() {
        this(10);
    }
    //add()方法：扩容为2倍，可以看到其中的方法都是上锁了的
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    //grow是add()中的一个关键方法，用于创建一个新的数组，一旦添加时超过现有容量时，会扩容为2倍
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);//这里1+1=2
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

public class Main {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
        deque.push(123);
        deque.push(456);
        System.out.println(deque.pop());//456
        System.out.println(deque.pop());//123
    }
}

public class Main {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("changlu");
        set.add("love");
        set.add("love");
        set.add("liner");
        //遍历Set集合，使用Iterator
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //love
  //changlu
  //liner
    }
}

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable{
    //内部实际上使用的是HashMap
    private transient HashMap<E,Object> map;
    //添加元素
    public boolean add(E e) {
        //直接使用了HashMap中的put()操作。
        return map.put(e, PRESENT)==null;
    }
}