常用集合ArrayList,LinkedList,HashMap,HashSet源码分析

常用集合ArrayList,LinkedList,HashMap,HashSet源码分析

（一）ArrayList，可自动扩充容量的动态数组

public class ArrayList<E> extends AbstractList<E> implements List<E>,
        RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8683452581122892189L;

    /** * * 所有ArrayList的元素都存储在此对象数组当中 * ArrayList的容量就是此数组的长度 */
    private transient Object[] elementData;

    /** * 实际拥有的元素的数量 * * @serial */
    private int size;

    /** * 构造方法一，指定elementData数组初始长度 */
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)    //小于0则抛出IllegalArgumentException
            throw new IllegalArgumentException("Illegal Capacity: "
                    + initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    /** * 构造方法二，默认elementData数组初始长度为10 */
    public ArrayList() {
        this(10);
    }

    /** * 构造方法三，构造一个包含指定 collection 的元素的List */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();      //toArray方法由AbstractCollection实现，返回一个对象数组
        size = elementData.length;      //元素的顺序是由迭代器迭代顺序决定的,详情见toArray方法实现
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)   //如果返回的不是一个数组对象
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

    /** * 修剪ArrayList的容量为实际size长度 */
    public void trimToSize() {
        modCount++;         //此方法改变了数组结构，需要检测是否同步
        int oldCapacity = elementData.length;
        if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }

    /** * * 扩充数组容量，并指定其最小的容量，即至少容量大小为minCapacity */
    public void ensureCapacity(int minCapacity) {
        modCount++;
        int oldCapacity = elementData.length;
        if (minCapacity > oldCapacity) {    //指定最小容量比原来容量大才扩充
            Object oldData[] = elementData;
            int newCapacity = (oldCapacity * 3) / 2 + 1;    //扩充原容量的1.5倍加1
            if (newCapacity < minCapacity)  //扩充后还是小于要求的最小容量，则扩充容量为最小容量
                newCapacity = minCapacity;
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

    /** * 返回List中的元素个数 */
    public int size() {
        return size;
    }

    /** * List是否不含元素 */
    public boolean isEmpty() {
        return size == 0;
    }

    /** * 查看o是否包含在ArrayList中，内部调用了indexOf方法实现 */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /** * 父类AbstractList的indexOf方法使用的是list迭代器遍历元素 * 这里重写了indexOf方法直接遍历数组即可 * 返回指定元素第一次在数组中出现的索引 * 如果找不到此元素则返回-1 */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /** * 基本同上 */
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size - 1; i >= 0; i--)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = size - 1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /** * * 返回ArrayList的浅拷贝实例对象，包含所有元素 */
    public Object clone() {
        try {
            ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {    //如果未实现Cloneable则会抛出CloneNotSupportedException
            throw new InternalError();
        }
    }

    /** * * 返回的对象数组是安全的，因为它是一个全新的对象 * 操作返回的数组并不会影响到ArrayList对象 * */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    /** * 返回一个指定类型的包含List所有元素的数组 */
    public <T> T[] toArray(T[] a) {
        if (a.length < size)    //如果a的长度小于List元素个数
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());    //以指定类型返回一个新数组，长度为size
        System.arraycopy(elementData, 0, a, 0, size);   //否则把elementData中元素复制到a
        if (a.length > size)    //如果a的长度大于size则在最后位置加一个null元素，等于的话就不用加了
            a[size] = null;     //这对了解它的实际长度很有效
        return a;
    }

    // Positional Access Operations

    public E get(int index) {
        RangeCheck(index);  //检查是否越界

        return (E) elementData[index];  //直接返回数组某位置的元素即可
    }

    /** * 对数组指定所有的值进行替换，并返回上一个值 */
    public E set(int index, E element) {
        RangeCheck(index);  //检查是否越界

        E oldValue = (E) elementData[index];    //so easy
        elementData[index] = element;
        return oldValue;
    }

    /** * 在数组size位置添加一个元素 * */
    public boolean add(E e) {
        ensureCapacity(size + 1); // modCount++,并检查是否需要扩充容量
        elementData[size++] = e;    //size++
        return true;
    }

    /** * * 在指定位置添加一个元素，当前在此位置的元素以及其后面的元素都要向后移动一个位置 * 此方法的效率较低 * */
    public void add(int index, E element) {
        if (index > size || index < 0)  //检查是否越界
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + size);

        ensureCapacity(size + 1); // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1, size
                - index);   //把原来index位置的元素，复制到index+1的位置，后面的size-index-1长度的元素依次复制
        elementData[index] = element;   //空出的index位置的元素设为element
        size++;
    }

    /** * * 移除指定位置的元素，其后面的元素都要向左移动一个位置 * 此方法的效率较低 */
    public E remove(int index) {
        RangeCheck(index);

        modCount++;     //modCount是为了检测是否发生了并发操作，详细见AbstractList类
        E oldValue = (E) elementData[index];

        int numMoved = size - index - 1;    //与add相比少移一个元素
        if (numMoved > 0)   //是否移除的是最后一个元素
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);  //index位置的元素被移除了，原来index+1位置的元素复制到index位置，随后的元素依次复制
        elementData[--size] = null; // Let gc do its work，size位置的元素空出来了

        return oldValue;
    }

    /** * * 如果o在List中存在，移除第一次出现在List中的o元素 * 如果o在List中不存在，不做任何操作 * */
    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;
    }

    /* * * 与remove(int index)方法差不多， * 不过不用检测是否越界与返回原来的index位置的值 */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved); 
        elementData[--size] = null; // Let gc do its work
    }

    /** * 移除所有元素，即把所有元素设为null，size=0 */
    public void clear() {
        modCount++;

        // Let gc do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

    /** * 把a中所有元素添加到数组尾部 */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacity(size + numNew); // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew); //从size位置开始复制a
        size += numNew;     //size增加
        return numNew != 0;
    }

    /** * * 在指定位置开始添加指定集合c中的所有元素 * 当前位置及其随后位置的元素后移 */
    public boolean addAll(int index, Collection<? extends E> c) {
        if (index > size || index < 0)  //检测是否越界
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + size);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacity(size + numNew); // Increments modCount

        int numMoved = size - index;    //移动元素数量
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                    numMoved);  //把原来index位置的元素，复制到index+numNew的位置，后面的size-index-1长度的元素依次复制

        System.arraycopy(a, 0, elementData, index, numNew); //空出来的位置填充c
        size += numNew;
        return numNew != 0;
    }

    /** * * 移除所有从fromIndex(包含)到toIndex(不包含)范围内的元素， * 左移随后的元素.如果toIndex=fromIndex，此操作无影响 * */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                        numMoved);  //把toIndex位置的元素复制到fromIndex，随后的元素依次复制，总共复制numMoved个元素

        // Let gc do its work
        int newSize = size - (toIndex - fromIndex); 
        while (size != newSize) //这里是为了让gc工作，不直接把size设为newSize
            elementData[--size] = null;
    }

    /** * * 这里并没有检测index小于0的情况 * 它总是由数组自己检测，抛出的异常也不同,为ArrayIndexOutOfBoundsException */
    private void RangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + size);
    }

    /** * 序列化ArrayList，保存ArrayList实例状态 * 保存的是数组长度，及其所有元素 * */
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // 写入数组长度
        s.writeInt(elementData.length);

        // 按顺序写入所有元素
        for (int i = 0; i < size; i++)
            s.writeObject(elementData[i]);

        if (modCount != expectedModCount) { //检测到了并发操作
            throw new ConcurrentModificationException();
        }

    }

    /** * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, * deserialize it). */
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // 读出数组长度
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength]; //保存

        // 依次读出所有元素
        for (int i = 0; i < size; i++)
            a[i] = s.readObject();
    }
}

（二）LikedList(双向循环链表)

public class LinkedList<E> extends AbstractSequentialList<E> implements
        List<E>, Deque<E>, Cloneable, java.io.Serializable {
    //在第一个节点之前附设的一个节点称为头结点，有元素添加会重设值
    //此变量在序列化时不保存
    private transient Entry<E> header = new Entry<E>(null, null, null); 
    private transient int size = 0;     //List存储的Entry对象个数

    /** * 构造方法一，空链表 */
    public LinkedList() {
        header.next = header.previous = header;  //只有一个头结点的链表
    }

    /** * 构造方法二，构造含有指定集合c中所有元素的链表 * 具体见addAll方法 */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    /** * 获取第一个元素的值，即头结点的下一个元素的数据部分 */
    public E getFirst() {
        if (size == 0)
            throw new NoSuchElementException();

        return header.next.element;
    }

    /** * 双向循环链表，你懂得 */
    public E getLast() {
        if (size == 0)
            throw new NoSuchElementException();

        return header.previous.element;
    }

    /** * 移除第一个元素，具体见remove()方法 */
    public E removeFirst() {
        return remove(header.next);
    }

    /** * 移除最后一个元素 */
    public E removeLast() {
        return remove(header.previous);
    }

    /** * * 在链表开始位置添加一个元素 * 详情见addBefore() */
    public void addFirst(E e) {
        addBefore(e, header.next);
    }

    /** * 在链表最后位置添加一个元素 * 详情见addBefore() */
    public void addLast(E e) {
        addBefore(e, header);
    }

    /** * 查看链表是否包含元素o * 详细见indexOf()方法 */
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

    /** * 链表所含元素的数量 */
    public int size() {
        return size;
    }

    /** * 跟addLast()方法类似，添加成功返回true */
    public boolean add(E e) {
        addBefore(e, header);
        return true;
    }

    /** * 假如链表中含有一个或多个o对象，移除第一次出现的o * 如果找不到o返回false */
    public boolean remove(Object o) {
        if (o == null) {
            for (Entry<E> e = header.next; e != header; e = e.next) {   //从第一个元素开始遍历，每一个Entry对象都包含它下一个元素的信息
                if (e.element == null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

    /** * * 把c中所有元素按顺序添加到链表尾部 */
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    /** * * 在指定位置按顺序添加c中所有元素带List中 * */
    public boolean addAll(int index, Collection<? extends E> c) {
        if (index < 0 || index > size)  //检查是否越界，=size表示添加到最后
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + size);
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;
        modCount++;     //对链表结构产生 影响的操作modCount都要加1，通过modCount可以检查是否对链表进行了并发操作

        Entry<E> successor = (index == size ? header : entry(index));
        Entry<E> predecessor = successor.previous;
        for (int i = 0; i < numNew; i++) {  //这里不难，画一个图就出来了，主要是初始化c和修改指针
            //暂时使其next为successor，因为e会赋给前驱,而每次遍历都要修改其前驱的next
            Entry<E> e = new Entry<E>((E) a[i], successor, predecessor);    //把c中元素依次存入Entry，设置其前驱和后继。
            predecessor.next = e;   //重新设置前驱的next指针
            predecessor = e;    //让e变为前驱
        }
        successor.previous = predecessor;   //successor的前驱为c中最后一个元素的引用

        size += numNew;     //长度加
        return true;
    }

    /** * 移除链表中所有元素 */
    public void clear() {
        Entry<E> e = header.next;
        while (e != header) {   //表示不是只有一个头结点的空链表
            Entry<E> next = e.next;
            e.next = e.previous = null; //let gc work
            e.element = null;
            e = next;
        }
        header.next = header.previous = header; //初始头结点
        size = 0;
        modCount++;
    }

    // Positional Access Operations

    /** * 返回指定位置的元素时 */
    public E get(int index) {
        return entry(index).element;
    }

    /** * 设置指定位置的元素 */
    public E set(int index, E element) {
        Entry<E> e = entry(index);
        E oldVal = e.element;
        e.element = element;
        return oldVal;
    }

    /** * * 把指定元素添加到指定位置，需先定位到此位置的节点 * 详情见addBefore() */
    public void add(int index, E element) {
        addBefore(element, (index == size ? header : entry(index)));
    }

    /** * 移除指定位置的元素 */
    public E remove(int index) {
        return remove(entry(index));
    }

    /** * * 返回指定索引位置的Entry对象，需要依次遍历得到。 * 这里稍做了一下优化，如果index < size/2 从前面开始遍历 * 如果index >= size/2 从后面开始遍历 */
    private Entry<E> entry(int index) {
        if (index < 0 || index >= size) //index在0(包含)到size(不包含)之间，索引从0开始
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next; //依次调用e.next才能得到,需调用index+1次，因为它是从头结点开始的
        } else {
            for (int i = size; i > index; i--)
                e = e.previous; //依次调用e.previous才能得到
        }
        return e;
    }

    // Search Operations

    /** * * 返回o第一次出现的位置，如果在List中找不到o返回-1 */
    public int indexOf(Object o) {
        int index = 0;  //链表的索引也是从0开始
        if (o == null) {
            for (Entry e = header.next; e != header; e = e.next) {  //从头结点开始，依次遍历
                if (e.element == null)
                    return index;
                index++;
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (o.equals(e.element))
                    return index;
                index++;
            }
        }
        return -1;
    }

    /** * 双向循环链表，从后面开始遍历即可 */
    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Entry e = header.previous; e != header; e = e.previous) {
                index--;
                if (e.element == null)
                    return index;
            }
        } else {
            for (Entry e = header.previous; e != header; e = e.previous) {
                index--;
                if (o.equals(e.element))
                    return index;
            }
        }
        return -1;
    }

    // Queue operations.有关队列的基本操作

    /** * 如果链表长度不为空，获取第一个元素 * 否则返回null */
    public E peek() {
        if (size == 0)
            return null;
        return getFirst();
    }

    /** * 跟peek方法相似，不过这里size为0的话直接抛出异常 */
    public E element() {
        return getFirst();
    }

    /** * 如果链表长度不为空，移除第一个元素,并返回它 * 否则返回null */
    public E poll() {
        if (size == 0)
            return null;
        return removeFirst();
    }

    /** * 与poll方法类似，不过长度为空，即header.next = header * 抛出NoSuchElementException */
    public E remove() {
        return removeFirst();
    }

    /** * 添加一个元素到链表尾部 */
    public boolean offer(E e) {
        return add(e);
    }

    // Deque operations
    /** * 添加一个元素到头结点之后，原来的第一个节点之前 */
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    /** * 在尾部添加一个元素 */
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

    /** * 获取第一个元素，如果size为0，返回空 * 否则返回第一个元素 */
    public E peekFirst() {
        if (size == 0)
            return null;
        return getFirst();
    }

    /** * 获取最后一个元素，如果size为0，返回空 * 否则返回最后一个元素 */
    public E peekLast() {
        if (size == 0)
            return null;
        return getLast();
    }

    /** * * 移除第一个元素并返回它 * 如果size为0则直接返回null */
    public E pollFirst() {
        if (size == 0)
            return null;
        return removeFirst();
    }

    /** * 移除最后一个元素并返回它 * 如果size为0则直接返回null */
    public E pollLast() {
        if (size == 0)
            return null;
        return removeLast();
    }

    /** * 在开始位置添加一个元素 */
    public void push(E e) {
        addFirst(e);
    }

    /** * 移除第一个元素 */
    public E pop() {
        return removeFirst();
    }

    /** * * 移除第一次出现的指定的元素 * 如果遍历整个List后没有找到o，则不做任何改变 * */
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }

    /** * 这个差不多，从后面开始遍历即可 */
    public boolean removeLastOccurrence(Object o) {
        if (o == null) {
            for (Entry<E> e = header.previous; e != header; e = e.previous) {
                if (e.element == null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry<E> e = header.previous; e != header; e = e.previous) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

    /** * * 返回一个list-iterator. */
    public ListIterator<E> listIterator(int index) {
        return new ListItr(index);
    }

    /** * 重新 实现ListIterator，使其跟符合链表的特性 * iterator方法由AbstractSequentialList实现了， * 但是调用的还是本ListIterator。只不过只能使用iterator接口的方法 * */
    private class ListItr implements ListIterator<E> {
        private Entry<E> lastReturned = header;     //上一次调用next或previous返回的元素，没有调用next则为头结点
        private Entry<E> next;  //下一次调用next方法返回的元素
        private int nextIndex;  //下一次调用next返回的元素的索引
        private int expectedModCount = modCount;    //用来检测遍历过程中是否产生了并发操作

        ListItr(int index) {    //构造器，是迭代器定位到index位置，要返回index位置的元素需调用一次next()方法时
            if (index < 0 || index > size)  
                throw new IndexOutOfBoundsException("Index: " + index
                        + ", Size: " + size);
            if (index < (size >> 1)) {  //从前面开始遍历
                next = header.next;  //这是index为0的元素
                for (nextIndex = 0; nextIndex < index; nextIndex++)
                    next = next.next;   //最终next为第index个元素，index从0开始
            } else {        //从后面开始遍历
                next = header;
                for (nextIndex = size; nextIndex > index; nextIndex--)
                    next = next.previous;   //最终next为第index个元素，index从0开始
            }
        }

        public boolean hasNext() {  //size位置可没有元素
            return nextIndex != size;
        }

        public E next() {
            checkForComodification();
            if (nextIndex == size)
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;   //这里与ArrayList中的cursor何其相似
            nextIndex++;
            return lastReturned.element;
        }

        public boolean hasPrevious() {
            return nextIndex != 0;
        }

        public E previous() {
            if (nextIndex == 0)
                throw new NoSuchElementException();

            lastReturned = next = next.previous;
            nextIndex--;
            checkForComodification();
            return lastReturned.element;
        }

        public int nextIndex() {    //返回下一次调用next返回的元素的索引
            return nextIndex;
        }

        public int previousIndex() {    //返回下一次调用previous返回的元素的索引
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            Entry<E> lastNext = lastReturned.next;
            try {
                LinkedList.this.remove(lastReturned);   //移除上一层调用next()或previous返回的元素
            } catch (NoSuchElementException e) {
                throw new IllegalStateException();
            }
            if (next == lastReturned)   //表明是调用previous后才调用remove方法
                next = lastNext;
            else
                nextIndex--;        //元素减少。nextIndex--
            lastReturned = header;  //重置lastReturned
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == header)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.element = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = header;
            addBefore(e, next); //在上一次调用next返回的元素之后，在上次调用previous返回的元素之前添加e
            nextIndex++;    //元素增加，索引增加，保证下次调用next()不是返回添加的元素
            expectedModCount++;
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    /** * LinkedList的元素节点，保存当前节点的元素 * 以及下一个节点，和上一个节点的引用 * 由此看出LinkedList是一个双向链表 */
    private static class Entry<E> {
        E element;          //当前节点元素
        Entry<E> next;      //下一个节点引用
        Entry<E> previous;  //上一个节点引用

        Entry(E element, Entry<E> next, Entry<E> previous) {
            this.element = element;
            this.next = next;
            this.previous = previous;
        }
    }

    /** * 在entry之前添加一个节点e * */
    private Entry<E> addBefore(E e, Entry<E> entry) {
        Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); //新节点的前驱和后继，只有一个元素的话前驱和后继都为header
        newEntry.previous.next = newEntry;  //新节点的前驱的后继为新节点，只包含newEntry一个元素的话修改的是头结点的next
        newEntry.next.previous = newEntry;  //新节点的后继的前驱为新节点,只包含newEntry一个元素的话修改的是头结点的previous
        size++;
        modCount++;
        return newEntry;
    }

    /** * 移除指定节点 */
    private E remove(Entry<E> e) {
        if (e == header)
            throw new NoSuchElementException();

        E result = e.element;
        //修改节点指针
        e.previous.next = e.next;   //e的前驱的后继等于e的后继
        e.next.previous = e.previous;   //e的后继的前驱等于e的前驱
        e.next = e.previous = null; //let gc work
        e.element = null;
        size--;     //size--
        modCount++;
        return result;
    }

    /** * 逆序返回所有元素的迭代器 */
    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }

    /** Adapter to provide descending iterators via ListItr.previous */
    private class DescendingIterator implements Iterator {
        final ListItr itr = new ListItr(size());

        public boolean hasNext() {
            return itr.hasPrevious();
        }

        public E next() {
            return itr.previous();
        }

        public void remove() {
            itr.remove();
        }
    }

    /** * 返回一个LikedList的浅拷贝对象 */
    public Object clone() {
        LinkedList<E> clone = null;
        try {
            clone = (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }

        // Put clone into "virgin" state，即重置其为初始状态
        clone.header = new Entry<E>(null, null, null);
        clone.header.next = clone.header.previous = clone.header;
        clone.size = 0;
        clone.modCount = 0;

        // 初始化克隆对象
        for (Entry<E> e = header.next; e != header; e = e.next)
            clone.add(e.element);

        return clone;
    }

    /** * 返回一个新建对象数组，包含链表中所有元素 */
    public Object[] toArray() {
        Object[] result = new Object[size]; //新建一size长度对象数组
        int i = 0;
        for (Entry<E> e = header.next; e != header; e = e.next) //遍历赋值
            result[i++] = e.element;
        return result;
    }

    /** * 所有toArray方法都是一个思想... * 只是遍历方式不同 * */
    public <T> T[] toArray(T[] a) {
        if (a.length < size)    //如果指定数组长度小于size，新建一数组
            a = (T[]) java.lang.reflect.Array.newInstance(a.getClass()
                    .getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Entry<E> e = header.next; e != header; e = e.next)
            result[i++] = e.element;

        if (a.length > size) //同ArrayList
            a[size] = null;

        return a;
    }

    private static final long serialVersionUID = 876323262645176354L;

    /** * 序列化LikedList，保存其状态 */
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        // Write out any hidden serialization magic
        //添加一些序列化的额外信息，表明它是一个序列化的文件
        s.defaultWriteObject();

        // 写长度
        s.writeInt(size);

        // 写元素
        for (Entry e = header.next; e != header; e = e.next)
            s.writeObject(e.element);
    }

    /** * 从流中读取 */
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // 读长度
        int size = s.readInt();

        // 初始化header
        header = new Entry<E>(null, null, null);
        header.next = header.previous = header;

        // 按顺序写入所有元素
        for (int i = 0; i < size; i++)
            addBefore((E) s.readObject(), header);
    }
}

（三）HashMap(数组加链表的结合体)

/** * 作用：用于实现快速查找 * HashMap实现的数据结构：动态数组和链表的结合体 * */
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>,
        Cloneable, Serializable {

    /** * 默认初始数组容量，必须为2的幂 */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /** * * 最大容量为1 * 2^30 即2的30次方 */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /** * * hashMap的加载系数，当数组中的元素增多时，通过hash函数算出的数组下标 * 相同几率增加。为保证查找的效率，当数组中的元素超过 * load_factor * table.length 时就要扩充容量 * 默认加载系数为0.75 */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /** * * 数组存放Entry对象，单向链表的第一个元素， * 通过它可以遍历整个链表。 * table长度会在需要时进行扩充，table长度始终为2的幂 */
    transient Entry[] table;

    /** * key-value键值对个数 */
    transient int size;

    /** * HashMap size >= threshlod时就扩充数组容量 */
    int threshold;

    /** * hash表加载因子 */
    final float loadFactor;

    /** * * hash表发生结构性改变的次数，这些方法包括，put，remove等对size进行改变的操作 * 用iterator遍历时可以用来检测是否对HashMap进行了并发操作 */
    transient volatile int modCount;

    /** * 根据指定的初始容量和加载系数构建hashMap * 初始容量如果不是2的幂，会被构造成2的幂 */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)    
            throw new IllegalArgumentException("Illegal initial capacity: "
                    + initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: "
                    + loadFactor);

        //找到一个2的幂的数，使其大于等于初始容量
        int capacity = 1;
        while (capacity < initialCapacity)  
            capacity <<= 1;         // capacity = capacity << 1,左移一位 

        this.loadFactor = loadFactor;
        threshold = (int) (capacity * loadFactor);
        table = new Entry[capacity];
        init(); //所有构造方法都含有此空方法，做一些其他初始化操作。根据业务要求，可由其子类实现
    }

    /** * 根据指定容量与默认加载系数构建HashMap */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /** * 采用默认容量16与默认加载系数0.75构建HashMap */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    /** * * 根据指定Map中的键值对,默认加载因子构建HashMap */
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, //size要小于容量*0.75
                DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m); 
    }

    // internal utilities

    /** * * 在new table之后，在添加元素之前被调用 */
    void init() {
    }

    /** * * hash算法，根据key的hashCode计算其hash值 * 此算法看的一知半解，大家有兴趣可以查看其它资料 * >>>无符号右移 ^按位异或 */
    static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /** * 根据hash值与数组长度计算其数组索引。 * length为2的幂，使不同hash通过h&(length-1)产生的索引尽量不同，即减少碰撞。 * 如果产生的索引都不同，通过找到索引就可以直接找到value，而不需要遍历链表。 * 可以使产生的索引始终在table索引范围之内 * 此方法详细解析可见：http://www.iteye.com/topic/539465 */
    static int indexFor(int h, int length) {
        return h & (length - 1);
    }

    /** * 键值对数目 */
    public int size() {
        return size;
    }

    /** * 判断hashMap是否为空 */
    public boolean isEmpty() {
        return size == 0;
    }

    /** * * 通过key值获得value，如果没有找到此key则返回null。 * 不过返回null也可能是其value为null * 通过contain方法可判断Map中是否含有此键 * */
    public V get(Object key) {
        if (key == null)    //空键另外处理
            return getForNullKey();
        int hash = hash(key.hashCode());
        //定位到index，并查看e的下一个节点是否为null，否则继续遍历
        for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    /** * * 空键的hash值为0，所以其数组中的索引为0. * 独立把此方法分离出来是为了提高两个最常用的方法get和put的性能， * 但在其它情况下此方法被合并了. */
    private V getForNullKey() {
        for (Entry<K, V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    /** * 如果Map中含有此key返回true. * 具体见getEntry. */
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    /** * * 通过返回Entry而不是value可确保Map中是否含有此key */
    final Entry<K, V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash
                    && ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

    /** * * replaced. * 通过指定的key值存储指定value，如果Map中含有此key则用指定value替换old value */
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);   //当你调用put并在替换老值时会调用此方法，假如你在这个时候想做一些额外操作可继承Entry重写此方法
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }


    private V putForNullKey(V value) {
        for (Entry<K, V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {    //如果含有此null key替换老值
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);    //否则添加此Entry到数组
        return null;
    }

    /** * * 此方法用来替代put方法，不会调整table大小。 * 此方法在确认map键值对个数始终小于table.length * load_factor， * 添加元素时调用。主要是为了提高性能 */
    private void putForCreate(K key, V value) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);

        /** * * 查看是否存在同样的key值，如果有就替换其value */
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash
                    && ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        //否则添加一个Entry对象
        createEntry(hash, key, value, i);
    }

    /** * 依次遍历添加 * */
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
                .entrySet().iterator(); i.hasNext();) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            putForCreate(e.getKey(), e.getValue());
        }
    }

    /** * * 当HashMap中元素越来越多时，发生碰撞的几率增大，为提高效率，当元素超过 * threshold时就要对数组进行扩充，扩充后，原数组中所有数据都要重新计算 * 其在新数组中的位置，所以每扩充一次对性能影响是非常大的。 */
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {  //如果数组容量已经最大，不再扩充。
            threshold = Integer.MAX_VALUE;      //使threshold = Integer.MAX_VALUE,使resize方法不再被调用
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int) (newCapacity * loadFactor);
    }

    /** * * 把table中所有的Entry对象转移到newTabel */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K, V> e = src[j];
            if (e != null) {
                src[j] = null;  //只置空第一个节点即可，因为此节点存在数组中
                do {
                    Entry<K, V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);  //根据新容量重新计算index
                    e.next = newTable[i];   //最后添加的节点放最前面
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    /** * * 把所有元素从知道map中复制到本map */
    public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        /* * * 如果numKeysToBeAdded大于或等于threshold就扩展map * 这是一个保守的方法。本来的条件应该是(m.size() + size) >= threshold, * 但是如果所有被添加的元素的key值在本map中都存在，map扩充的容量将是 * 最佳容量的两倍。这极大的浪费了空间，所以采用此保守的方法计算newCapacity。 * 否则不再此处扩充就在put方法中进行扩充 */
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int) (numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;  
            if (newCapacity > table.length)
                resize(newCapacity);
        }

        //依次遍历添加
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
                .entrySet().iterator(); i.hasNext();) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

    /** * 根据知道key移除键值对，返回移除的元素 */
    public V remove(Object key) {
        Entry<K, V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    /** * 根据key移除Entry对象 */
    final Entry<K, V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K, V> prev = table[i];
        Entry<K, V> e = prev;

        while (e != null) {
            Entry<K, V> next = e.next;
            Object k;
            if (e.hash == hash
                    && ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)  //表明链表只有一个Entry对象
                    table[i] = next;
                else
                    prev.next = next;   //修改指针
                e.recordRemoval(this);  //在移除元素时调用
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    /** * 同remove方法基本相似 */
    final Entry<K, V> removeMapping(Object o) {
        if (!(o instanceof Map.Entry))
            return null;

        Map.Entry<K, V> entry = (Map.Entry<K, V>) o;
        Object key = entry.getKey();
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K, V> prev = table[i];
        Entry<K, V> e = prev;

        while (e != null) {
            Entry<K, V> next = e.next;
            if (e.hash == hash && e.equals(entry)) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    /** * 移除所有元素 */
    public void clear() {
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;  //只要把数组置空即可
        size = 0;
    }

    /** * 是否包含次value */
    public boolean containsValue(Object value) {
        if (value == null)
            return containsNullValue();

        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                if (value.equals(e.value))
                    return true;
        return false;
    }

    /** * 是否包含空值 */
    private boolean containsNullValue() {
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                if (e.value == null)
                    return true;
        return false;
    }

    /** * 返回HashMap的浅拷贝实例 */
    public Object clone() {
        HashMap<K, V> result = null;
        try {
            result = (HashMap<K, V>) super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }

        result.table = new Entry[table.length];
        result.entrySet = null;     
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);   //依次添加本map所有元素到浅拷贝的map实例中

        return result;
    }

    static class Entry<K, V> implements Map.Entry<K, V> {
        final K key;
        V value;
        Entry<K, V> next;
        final int hash;

        /** * Creates new entry. */
        Entry(int h, K k, V v, Entry<K, V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        //Entry的equals方法，键值相等即Entry对象相等
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry) o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        /** * 重写hashCode方法，异或key与value的hashCode值 */
        public final int hashCode() {
            return (key == null ? 0 : key.hashCode())
                    ^ (value == null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /** * * 当添加一键值对，发现键已存在时调用此方法 * 可以继承Entry对象重写此方法 */
        void recordAccess(HashMap<K, V> m) {
        }

        /** * 当有Entry对象被移除时，此方法被调用。 * 可以继承Entry对象重写此方法 */
        void recordRemoval(HashMap<K, V> m) {
        }
    }

    /** * * 如果适当此方法会resize table */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K, V> e = table[bucketIndex];  
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
        if (size++ >= threshold)    //如果size超过threshold就调整数组容量大小为原来的两倍
            resize(2 * table.length);
    }

    /** * * 与addEntry方法类似。但是方法不需要担心容量的扩充 */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K, V> e = table[bucketIndex]; //如果此节点已经有一个Entry对象，返回e，否则返回null
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);  //以新加入的节点作为第一个节点
        size++;
    }

    /** * 抽象类，next方法由其子类实现， * 不同的next方法返回不同的迭代器 * 包括key，value，keySet迭代器 * */
    private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K, V> next; // next entry to return
        int expectedModCount; // For fast-fail
        int index; // current slot
        Entry<K, V> current; // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                //遍历直到获取第一个Entry对象，因为有的索引可能为空
                while (index < t.length && (next = t[index++]) == null) 
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        /** * 返回下一个Entry对象 * */
        final Entry<K, V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K, V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                //继续找不为空的索引中的Entry对象
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

        /** * 移除当前Entry对象，即调用nextEntry返回的Entry对象 */
        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);  //此方法会改变modCount
            expectedModCount = modCount;    //所以可以用此语句检测是否产生了并发操作
        }

    }

    //依次重写next方法，返回不同的迭代器。

    private final class ValueIterator extends HashIterator<V> {
        public V next() {
            return nextEntry().value;
        }
    }

    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

    private final class EntryIterator extends HashIterator<Map.Entry<K, V>> {
        public Map.Entry<K, V> next() {
            return nextEntry();
        }
    }

    // Subclass overrides these to alter behavior of views' iterator() method
    Iterator<K> newKeyIterator() {
        return new KeyIterator();
    }

    Iterator<V> newValueIterator() {
        return new ValueIterator();
    }

    Iterator<Map.Entry<K, V>> newEntryIterator() {
        return new EntryIterator();
    }

    // Views

    private transient Set<Map.Entry<K, V>> entrySet = null;

    /** * 返回一个key集。 * 此Set集合只在第一次调用keySet()时被创建，此后返回的都是同一个Set。 * 此方法不是线程安全的，大量线程多次调用此方法返回的可能不是同一个Set（可能是重新new的） * * 对map的修改会反应到Set当中，相反，对Set中key进行移除操作，比如 * Iterator.remove,Set.remove ,removeAll,retainAll,clear等操作时被移除的键 * 和它相关联的值也将从map中被移除，但是此Set不支持任何添加操作 */
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }

        public int size() {
            return size;
        }

        public boolean contains(Object o) {
            return containsKey(o);
        }

        /** * 重写了Set的remove方法， * 父类remove都是调用迭代器的remove方法 * */
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }

        public void clear() {
            HashMap.this.clear();
        }
    }

    /** * 同上 */
    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    private final class Values extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return newValueIterator();
        }

        public int size() {
            return size;
        }

        public boolean contains(Object o) {
            return containsValue(o);
        }

        public void clear() {
            HashMap.this.clear();
        }
    }

    /** * 同上 */
    public Set<Map.Entry<K, V>> entrySet() {
        return entrySet0();
    }

    private Set<Map.Entry<K, V>> entrySet0() {
        Set<Map.Entry<K, V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    private final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
        public Iterator<Map.Entry<K, V>> iterator() {
            return newEntryIterator();
        }

        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K, V> e = (Map.Entry<K, V>) o;
            Entry<K, V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }

        public boolean remove(Object o) {
            return removeMapping(o) != null;
        }

        public int size() {
            return size;
        }

        public void clear() {
            HashMap.this.clear();
        }
    }

    /** * 序列化hashMap对象 */
    private void writeObject(java.io.ObjectOutputStream s) throws IOException {
        Iterator<Map.Entry<K, V>> i = (size > 0) ? entrySet0().iterator()
                : null;

        // 写入默认信息
        s.defaultWriteObject();

        // 写入可以存储的容量
        s.writeInt(table.length);

        // 写入实际长度
        s.writeInt(size);

        // Write out keys and values (alternating)
        if (i != null) {
            while (i.hasNext()) {   //依次写入键值对
                Map.Entry<K, V> e = i.next();
                s.writeObject(e.getKey());
                s.writeObject(e.getValue());
            }
        }
    }

    private static final long serialVersionUID = 362498820763181265L;

    /** * 读出HashMap对象 */
    private void readObject(java.io.ObjectInputStream s) throws IOException,
            ClassNotFoundException {
        //读出默认信息
        s.defaultReadObject();

        // 读容量
        int numBuckets = s.readInt();
        table = new Entry[numBuckets];

        init(); // Give subclass a chance to do its thing.

        // 读长度
        int size = s.readInt();

        //读键值对，并还原HashMap元素
        for (int i = 0; i < size; i++) {
            K key = (K) s.readObject();
            V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }

    // These methods are used when serializing HashSets
    int capacity() {
        return table.length;
    }

    float loadFactor() {
        return loadFactor;
    }
}

（四）HashSet

/** * 散列集（hashSet）,就是不存在重复元素的集合。 * HashSet是在HashMap的基础上实现的， * 以HashSet的元素做Key值使其值不会重复 * */
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable,
        java.io.Serializable {
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E, Object> map;


    //以Object作为虚假的Value值
    private static final Object PRESENT = new Object();

    /** * * 构造一个新的，空Set集； * 实际是构造一个默认初始容量为16，加载因子为0.75的空HashMap */
    public HashSet() {
        map = new HashMap<E, Object>();
    }

    /** * * 构造一个包含指定集合c中所有元素的新的Set集。 * 实际是构造包含集合c中所有元素的HashMap. * 初始大小必须大于容量*0.75 * */
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<E, Object>(Math.max((int) (c.size() / .75f) + 1, 16));
        addAll(c);
    }

    /** * 以指定初始容量和加载因子构造HashMap */
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<E, Object>(initialCapacity, loadFactor);
    }

    /** * 以初始容量构造HashMap */
    public HashSet(int initialCapacity) {
        map = new HashMap<E, Object>(initialCapacity);
    }

    /** * * 构造一个Linked hash set. * 以指定初始容量，加载因子构造LinkedHashMap，dummy只是为了区别其他构造方法 * */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<E, Object>(initialCapacity, loadFactor);
    }

    /** * 获得HashMap的键集迭代器 */
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    /** * 返回元素个数 */
    public int size() {
        return map.size();
    }

    /** * 判断Hash集是否为空 */
    public boolean isEmpty() {
        return map.isEmpty();
    }

    /** * 如果Map中含有此key则返回true */
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    /** * * 如果e不存在于Set中则添加e到集合， * 如果Map中key集不存在e，则添加并返回null，否则替换原来的value，返回oldValue * */
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }

    /** * 移除指定元素 */
    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }

    /** * 清空map */
    public void clear() {
        map.clear();
    }

    /** * 返回HashSet的浅拷贝对象 */
    public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();  
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }


    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();

        //写入HashMap的容量和加载系数
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());

        //写入size
        s.writeInt(map.size());

        //依次写入键值
        for (Iterator i = map.keySet().iterator(); i.hasNext();)
            s.writeObject(i.next());
    }


    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        //读取容量和加载因子构造HashMap
        int capacity = s.readInt();
        float loadFactor = s.readFloat();
        //判断是LinkedHashMap还是HashMap
        map = (((HashSet) this) instanceof LinkedHashSet ? new LinkedHashMap<E, Object>(
                capacity, loadFactor)
                : new HashMap<E, Object>(capacity, loadFactor));

        // 读size
        int size = s.readInt();

        //依次读出所有元素
        for (int i = 0; i < size; i++) {
            E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }
}