Java集合——Collection接口

Java集合——Collection接口

摘要：本文主要介绍了Java集合的Collection接口。

概述

Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性。Collection包含了List和Set两大分支。

常用方法

添加单个元素：boolean add(Object object);

添加一个集合里的所有元素：boolean addAll(Collection<? extends E> collection);

删除单个元素：boolean remove(Object object);

删除指定集合里有的元素：boolean removeAll(Collection collection);

删除两个集合都有的元素：boolean retainAll(Collection collection);

判断是否包含某个元素：boolean contains(Object object);

判断是否包含指定集合的所有元素：boolean containsAll(Collection<?> collection);

判断集合是否为空：boolean isEmpty();

清除集合里的元素：void clear();

获取集合元素个数：int size();

将集合转换为数组：Object[] toArray();

将集合转换为指定类型的数组：<T> T[] toArray(T[] array);

获取集合迭代器：Iterator iterator();

集合同数组的比较

数组长度一旦固定，不能再改变，集合的长度是可以改变的。

数组只能保存相同类型的数据，集合可以保存指定类型或其子类型的数据。

数组在使用的时候相对比较麻烦，集合可以利用多种方法，还有工具类。

List接口

List接口继承自Collection接口，允许定义一个重复的有序集合，集合中的每个元素都有对应的一个索引，可以通过索引访问List中的元素。

实现List接口的实现类主要有：ArrayList、LinkedList、Vector、Stack。

特点

允许重复。

有序，取出的顺序和插入的顺序一致。

为每一个元素提供一个索引值，默认从0开始。

常用方法

在指定索引位置添加单个元素：void add(int index, Object object);

在指定索引位置添加一个集合：boolean addAll(int index, Collection<? extends E> collection);

删除指定位置的单个元素：Object remove(int index);

获取指定位置的单个元素：Object get(int index);

替换指定位置的单个元素：Object set(int index, Object object);

获取指定元素的出现的第一个索引：int indexOf(Object object);

获取指定元素的出现的最后一个索引：int lastIndexOf(Object object);

获取指定位置的集合，包含起始位置，不包含结束位置：List<E> subList(int fromIndex, int toIndex);

获取集合迭代器：ListIterator<E> listIterator();

ArrayList类

特点

ArrayList是动态数组结构，也是我们最常用的集合，允许任何符合规则的元素插入，包括null。

ArrayList提供了索引机制，可以通过索引迅速查找元素，查找效率高。但是每次增加或删除元素时，身后的元素都要移动，所以增删效率低。

ArrayList的操作是非同步的，是线程不安全的。

扩容机制

数组结构都会有容量的概念，ArrayList的初始容量为10，加载因子是1，当快插入元素后长度超出原有长度时会进行扩增，扩容增量是0.5，扩增后容量为1.5倍，可使用方法手动扩容和缩减。

如果一开始就明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间和效率。

属性

// 默认的初始容量为10。
private static final int DEFAULT_CAPACITY = 10;
// 空数组。
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认容量的空数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 数组。
transient Object[] elementData;
// 元素个数。
private int size;

构造方法

// 空参构造器，返回默认容量为10的集合。
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 指定长度的构造器，如果长度为0，则返回容量为0的集合。
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);
    }
}

// 传入了一个集合的构造器，如果集合长度为0，返回容量为0的集合。
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // Object[]数组里的类型不一定都是Object类型的，有可能是Object的子类，所以要判断一下。
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

常用方法

// 对集合进行扩容。
public void ensureCapacity(int minCapacity) {
    // 如果集合不为空，则设置扩充值为0，如果为空，则设置扩充值为10。
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
    // 如果指定容量大于扩充值，则进行扩容。
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

// 对集合进行扩容。
private void ensureCapacityInternal(int minCapacity) {
    // 如果集合为空，则在默认大小和最小值之间取最大的。
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 进行扩容。
    ensureExplicitCapacity(minCapacity);
}

// 对集合进行扩容，实际操作。
private void ensureExplicitCapacity(int minCapacity) {
    // 操作数加一。
    modCount++;
    // 如果最小值大于数组长度，则进行扩容。
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

// 扩容计算。
private void grow(int minCapacity) {
    // 获取原容量大小。
    int oldCapacity = elementData.length;
    // 右移一位，变为原来的0.5倍，然后加上原大小，扩容后变为1.5倍。
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果扩容后小于最小值，则设置容量为最小值。
    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 int hugeCapacity(int minCapacity) {
    // 如果最小值小于零，则表示溢出，抛出内存溢出异常。
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    // 如果扩容后的值大于最大值，则使用Integer的最大值，否则就使用最大值。
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

// 获取指定下标的元素。
public E get(int index) {
    // 检查指定下标是否越界。
    rangeCheck(index);
    // 返回指定下标的元素。
    return elementData(index);
}

// 设置指定下标的指定元素，并返回旧元素。
public E set(int index, E element) {
    // 检查指定下标是否越界。
    rangeCheck(index);
    // 设置指定元素并返回旧元素。
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

// 添加元素，并返回是否成功。
public boolean add(E e) {
    // 扩容并增加操作数。
    ensureCapacityInternal(size + 1);
    // 元素个数增加并设置指定元素。
    elementData[size++] = e;
    // 返回成功。
    return true;
}

// 在指定位置添加指定元素。
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 = elementData(index);
    // 需要移动的元素个数。
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 将最后一个元素设置为null并减少容量大小。
    elementData[--size] = null;
    // 返回指定下标的元素。
    return oldValue;
}

// 删除第一次出现的指定元素。
public boolean remove(Object o) {
    // 如果指定元素是null。
    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;
}

遍历方法

ArrayList提供了两种迭代器，实现了Iterator接口的Itr类，以及实现了ListIterator接口并继承了Itr类的ListItr类。

ListItr类对Itr类的方法进行了扩展，提供了添加和修改的方法，这里只学习Itr类。

// 获取Iterator迭代器。
public Iterator<E> iterator() {
    return new Itr();
}

// Iterator内部类，实现了Iterator接口。
private class Itr implements Iterator<E> {
    // 下一个元素的位置。
    int cursor;
    // 最后一个元素的位置。
    int lastRet = -1;
    // 预期的操作数。
    int expectedModCount = modCount;

    // 是否存在下一个元素。
    public boolean hasNext() {
        return cursor != size;
    }

    // 获取下一个元素。
    @SuppressWarnings("unchecked")
    public E next() {
        // 校验预期操作数和实际操作数。
        checkForComodification();
        // 将下一个元素的位置赋值给i。
        int i = cursor;
        // 如果i大于或等于集合大小，说明没有元素了，抛出异常。
        if (i >= size)
            throw new NoSuchElementException();
        // 获取集合数组。
        Object[] elementData = ArrayList.this.elementData;
        // 如果i大于或等于数组长度，说明有其他线程改过了，抛出异常。
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 下一个元素位置加一。
        cursor = i + 1;
        // 获取元素并返回，设置最后一个元素位置。
        return (E) elementData[lastRet = i];
    }

    // 删除当前元素。
    public void remove() {
        // 如果当前位置小于零，抛出异常。
        if (lastRet < 0)
            throw new IllegalStateException();
        // 校验预期操作数和实际操作数。
        checkForComodification();
        try {
            // 移除当前位置上的元素。
            ArrayList.this.remove(lastRet);
            // 将当前位置赋值给下一个元素位置。
            cursor = lastRet;
            // 将当前位置设置为-1，表示没有此位置。
            lastRet = -1;
            // 同步预期操作数和操作数。
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    // 循环遍历一次，JDK1.8新增方法。
    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        // 判断非空。
        Objects.requireNonNull(consumer);
        // 集合容量大小。
        final int size = ArrayList.this.size;
        // 将下一个元素的位置赋值给i。
        int i = cursor;
        // 如果i大于或等于集合长度，则返回。
        if (i >= size) {
            return;
        }
        // 获取集合数组。
        final Object[] elementData = ArrayList.this.elementData;
        // 如果i大于或等于数组长度，说明有其他线程改过了，抛出异常。
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        // 循环遍历，当下一个元素不为集合的大小，并且预期操作数和实际操作数相等。
        while (i != size && modCount == expectedModCount) {
            // 执行方法，并且每次循环i加一。
            consumer.accept((E) elementData[i++]);
        }
        // 将循环后的i赋值，导致下个元素的位置和集合长度相等，该迭代器不能再次遍历集合了。
        cursor = i;
        // 设置最后一个元素位置。
        lastRet = i - 1;
        // 校验预期操作数和实际操作数。
        checkForComodification();
    }

    // 校验预期操作数和实际操作数。
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

Vector类

特点

与ArrayList相似，它的操作与ArrayList几乎一样。

Vector是同步的，是线程安全的动态数组，但是效率低。

扩容机制

初识容量为10，加载因子为1，扩容增量是1，扩增后容量为原来长度的2倍，适用于数据量大的环境。

LinkedList类

特点

LinkedList是双向链表结构，额外提供了操作列表首尾元素的方法，因为不是数组结构，所以不存在扩容机制。

LinkedList使用了链表结构，通过修改前后两个元素的链接指向实现增加和删除操作，增删效率高，但是查找操作必须从开头或者结尾便利整个列表，所以查找效率低。

LinkedList的操作是非同步的，是线程不安全的。

插入方法

// 在首部位置插入元素。
public void push(E e) {
    addFirst(e);
}
    
// 在尾部位置插入元素。
public boolean offer(E e) {
    return add(e);
}

// 在首部位置插入元素。
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

// 在尾部位置插入元素。
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

// 在指定位置插入元素。
public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

// 在尾部位置插入元素。
public boolean add(E e) {
    linkLast(e);
    return true;
}

// 在首部位置插入元素。
public void addFirst(E e) {
    linkFirst(e);
}

// 在尾部位置插入元素。
public void addLast(E e) {
    linkLast(e);
}

// 在首部位置插入元素。
private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

// 在尾部位置插入元素。
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++;
}

// 在指定元素前插入元素。
void linkBefore(E e, Node<E> 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++;
}

删除方法

// 删除首部位置元素，并返回删除的元素。
public E pop() {
    return removeFirst();
}

// 删除首部位置元素，并返回删除的元素。
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

// 删除首部位置元素，并返回删除的元素。
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

// 删除尾部位置元素，并返回删除的元素。
public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

// 删除首部位置元素，并返回删除的元素。
public E remove() {
    return removeFirst();
}

// 删除指定位置元素，并返回删除的元素。
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

// 删除指定元素。
public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

// 删除首部位置元素，并返回删除的元素。
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

// 删除尾部位置元素，并返回删除的元素。
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

// 删除首部位置元素，并返回删除的元素。
private E unlinkFirst(Node<E> f) {
    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;
}

// 删除尾部位置元素，并返回删除的元素。
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

// 删除指定节点元素，并返回删除的元素。
E unlink(Node<E> 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 E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

// 获取首部节点。
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

// 获取尾部节点。
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

// 获取指定位置的元素。
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 获取首部节点。
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

// 获取尾部节点。
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

遍历方法

LinkedList同样支持两种迭代器。

LinkedList支持多种遍历方式，建议不要采用随机访问的方式去遍历LinkedList，而采用逐个遍历的方式。

// 通过迭代器遍历。
for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
    System.out.println(iter.next());
}

// 通过普通for循环遍历，不建议使用这种方式遍历。
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 通过增强for循环来遍历。
for (String string : list) {
    System.out.println(string);
}

// 通过removeFirst()方法来遍历，建议使用这种方式遍历，但是要注意可能会抛出异常。
String string;
try {
    while ((string = list.removeFirst()) != null) {
        System.out.println(string);
    }
} catch (NoSuchElementException e) {
    e.printStackTrace();
}

Set接口

Set接口继承自Collection接口，允许定义一个不重复的无序集合，集合中只允许存在一个null值。

实现Set接口的实现类主要有：HashSet、LinkedHashSet、TreeSet。

特点

不可以重复，只能插入一个空值。

无序，不能保证插入的顺序和输出的顺序一致。

没有索引。

HashSet类

特点

HashSet的底层是HashMap。

HashSet使用了一个散列集存储数据，通过元素的Hash值进行排序，不能保证插入和输出的顺序一致。

HashSet不能插入重复的元素，只能存在一个null值。

HashSet内部通过哈希表进行排序，具有很好的查找和存取功能。

HashSet是非同步的，线程不安全。

扩容机制

和HashMap相同。

LinkedHashSet类

特点

LinkedHashSet继承自HashSet，其底层是基于LinkedHashMap来实现的。

LinkedHashSet使用链表维护元素的次序，同时根据元素的hash值来决定元素的存储位置，遍历集合时候，会以元素的添加顺序访问集合的元素。

LinkedHashSet不能插入重复的元素，只能存在一个null值。

LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。

LinkedHashSet是非同步的，线程不安全。

扩容机制

和HashMap相同。

TreeSet类

特点

TreeSet的底层是TreeMap。

TreeSet基于二叉树结构，可以实现自然排序。

TreeSet通过比较方法的返回值来判断元素是否相等，因此不能添加null的数据，不能添加重复元素，只能插入同一类型的数据。

TreeSet支持两种排序方式，自然排序和定制排序。

自动排序：添加自定义对象的时候，必须要实现Comparable接口，并要覆盖compareTo方法来自定义比较规则。

定制排序：创建TreeSet对象时，传入Comparator接口的实现类。要求Comparator接口的compare方法的返回值和两个元素的equals方法具有一致的返回值。