揭秘Java集合框架核心原理：源码深度解析与实战技巧

Java集合框架是Java语言中一个非常重要的部分，它提供了各种数据结构来存储和操作对象。掌握Java集合框架的核心原理对于提升Java编程能力至关重要。本文将深入解析Java集合框架的源码，并分享一些实战技巧。

一、Java集合框架概述

Java集合框架包含以下主要接口：

Collection：集合接口，是集合框架的根接口。
List：有序集合接口，元素可以重复。
Set：无序集合接口，元素不能重复。
Queue：队列接口，用于存储先进先出（FIFO）或后进先出（LIFO）的元素。
Deque：双端队列接口，是Queue接口的子接口，支持在两端进行元素插入和删除。

Java集合框架还包括以下主要类：

ArrayList：基于动态数组的实现，提供快速的随机访问。
LinkedList：基于双向链表的实现，提供高效的插入和删除操作。
HashSet：基于哈希表的实现，提供高效的查找和删除操作。
TreeSet：基于红黑树的实现，提供有序集合。
PriorityQueue：基于优先队列的实现，提供最高优先级元素的高效访问。

二、源码深度解析

1. ArrayList

ArrayList基于动态数组实现，其源码如下：

”`java public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable {

private static final long serialVersionUID = 8683452581122892189L;
private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
private int size;

public ArrayList() {
    this.elementData = DEFAULT_CAPACITY;
}

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    if (minCapacity - elementData.length > 0) {
        grow(minCapacity);
    }
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        newCapacity = hugeCapacity(minCapacity);
    }
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) {
        throw new OutOfMemoryError();
    }
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

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];
    elementData[index] = element;
    return oldValue;
}

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;
}

public void remove(int index) {
    rangeCheck(index);
    modCount++;
    System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
    elementData[--size] = null;
}

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;
}

private void fastRemove(int index) {
    modCount++;
    System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
    elementData[--size] = null;
}

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    modCount++;
    int r = 0, w = 0;
    boolean modified = false;
    while (r < size) {
        if (!(c.contains(elementData[r]))) {
            elementData[w++] = elementData[r];
        } else {
            modified = true;
        }
        r++;
    }
    if (modified) {
        size = w;
        System.arraycopy(elementData, w, elementData, 0, size);
    }
    return modified;
}

public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    modCount++;
    int r = 0, w = 0;
    boolean modified = false;
    while (r < size) {
        if (c.contains(elementData[r])) {
            elementData[w++] = elementData[r];
        } else {
            modified = true;
        }
        r++;
    }
    if (modified) {
        size = w;
        System.arraycopy(elementData, w, elementData, 0, size);
    }
    return modified;
}

public void clear() {
    modCount++;
    elementData = (size == 0) ? EMPTY_ELEMENTDATA : new Object[size];
}

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        return v;
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);
    System.arraycopy(elementData, index, elementData, index + numNew, size - index);
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
}

public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = (E) elementData[index];
    int numMoved = size - index - 1;
    if (numMoved > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    }
    elementData[--size] = null;
    return oldValue;
}

public int size() {
    return size;
}

public boolean isEmpty() {
    return size == 0;
}

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

public <T> T[] toArray(T[] a) {
    if (a.length < size) {
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    }
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size) {
        a[size] = null;
    }
    return a;
}

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;        // index of next element to return
    int lastRet = -1;   // index of last returned element
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        checkForComodification();
        int lastRet = this.lastRet;
        if (lastRet == -1)
            throw new IllegalStateException();
        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException e) {
            throw new ConcurrentModificationException();
        }
    }

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

public ListIterator<E> listIterator(int index) {
    return new ListItr(index);
}

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

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

    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i];
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    public void set(E e) {
        if (lastRet == -1)
            throw new IllegalStateException();
        checkForComodification();
        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();
        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

public ListIterator<E> listIterator() {
    return new ListItr(0);
}

public Iterator<E> iterator(int index) {
    return new Itr(index);
}

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;
}

public void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    }
    elementData[--size] = null;
}

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;
}

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        return v;
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);
    System.arraycopy(elementData, index, elementData, index + numNew, size - index);
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = (E) elementData[index];
    elementData[index] = element;
    return oldValue;
}

public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = (E) elementData[index];
    int numMoved = size - index - 1;
    if (numMoved > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    }
    elementData[--size] = null;
    return oldValue;
}

public int size() {
    return size;
}

public boolean isEmpty() {
    return size == 0;
}

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

public <T> T[] toArray(T[] a) {
    if (a.length < size) {
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    }
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size) {
        a[size] = null;
    }
    return a;
}

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;        // index of next element to return
    int lastRet = -1;   // index of last returned element
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        checkForComodification();
        int lastRet = this.lastRet;
        if (lastRet == -1)
            throw new IllegalStateException();
        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException e) {
            throw new ConcurrentModificationException();
        }
    }

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

public ListIterator<E> listIterator(int index) {
    return new ListItr(index);
}

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

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

    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i];
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    public void set(E e) {
        if (lastRet == -1)
            throw new IllegalStateException();
        checkForComodification();
        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();
        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {

正文

揭秘Java集合框架核心原理：源码深度解析与实战技巧

一、Java集合框架概述

二、源码深度解析

1. ArrayList

相关阅读

掌握Java核心，春意盎然！一招入门Spring框架，开启高效开发之旅

揭秘Java集合框架：源码深度解析，从入门到精通

揭秘Java集合框架：源码揭秘，高效编程技巧全解析

掌握Java集合框架核心，源码剖析，从入门到精通

Java集合框架原理深度剖析：从源码看ArrayList、LinkedList等核心类实现

揭秘AJAX在前端框架中的巧妙应用，提升网页互动体验全攻略

揭秘Java集合框架源码：全面解读ArrayList、LinkedList等核心类原理与优化技巧

揭秘Java开源框架MyBatis：高效ORM，轻松实现数据库操作，新手必学技巧！

如何轻松搭建高效Web表单：盘点最受欢迎的表单开发框架及使用技巧

掌握这些主流Web前端开发框架，轻松打造高性能网页应用