Java集合框架：Collection接口概览

最新推荐文章于 2025-05-10 17:17:50 发布

索茄啦你

最新推荐文章于 2025-05-10 17:17:50 发布

阅读量228

点赞数

分类专栏： Java集合框架_Collection_非线程安全文章标签： java

本文链接：https://blog.youkuaiyun.com/m0_37567491/article/details/104522171

版权

Java集合框架_Collection_非线程安全专栏收录该内容

7 篇文章

订阅专栏

本文概述了Java集合框架中的Collection接口，包括其作为Iterable接口的子接口，以及Collection接口下的一些主要子接口，如List、Set、SortedSet、NavigableSet、Queue和Deque。通过对各接口的继承关系、声明方法和部分源码示例的解析，深入理解这些接口在实际编程中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Collection接口概览

Iterable接口

lterable继承关系：

lterable接口声明方法：

iterator()	返回集合类型的内部迭代器
forEach(Consumer<? super T> action)	有默认实现方法的forEach（lambda）
spliterator()	有默认的实现方法，用于集合的并行遍历

lterable接口的部分源码：

public interface Iterable<T> {

    // 返回一个迭代器
    Iterator<T> iterator();

    // 默认实现的遍历方法
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    // 返回一个用于并行遍历的迭代器
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }

}

ArrayList实现类部分源码：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{    

    // iterator方法返回一个实现了Iterator接口的类
    public Iterator<E> iterator() {
        return new Itr();
    }

    // ArrayList的私有类，实现了Iterator接口
    private class Itr implements Iterator<E> {
        ...
    }

}

举例：

    @Test
    void iterable() {
        List<Integer> integers = new ArrayList<>(List.of(0, 1, 2, 3, 4, 5));

        // 返回ArrayList的内部迭代器
        Iterator<Integer> iterator = integers.iterator();

        // 遍历
        integers.forEach(System.out::println);

        // 并行遍历
        Spliterator<Integer> spliterator = integers.spliterator();
        spliterator.forEachRemaining(System.out::println);
    }

Collection接口

Collection继承关系

Collection接口声明方法：

contains(Object o)	若此集合包含指定元素，返回true
containsAll(Collection<?> c)	若此集合包含指定的集合，返回true
toArray()	返回包含此集合所有元素的数组
toArray(T[] a)	将集合转化为所需类型的数组
toArray(IntFunction<T[]> generator)	返回集合元素通过generator函数处理后的数组
removeIf(Predicate<? super E> filter)	删除符合条件的集合元素（lambda）
retainAll(Collection<?> c)	从集合中删除所有未包含在指定集合中的元素
stream()	返回以该集合为源的流
parallelStream()	返回以该集合为源的并行流（也允许返回顺序流）

Collection的部分源码：

// Collection接口 继承自 Iterable接口
public interface Collection<E> extends Iterable<E> {

    // 集合转换为Object类型数组
    Object[] toArray();

    // 集合转换为特定类型的数组
    <T> T[] toArray(T[] a);

    // 返回集合各元素经过generator函数处理后的数组
    default <T> T[] toArray(IntFunction<T[]> generator) {
        return toArray(generator.apply(0));
    }

    // 删除符合条件的元素
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        // 获取迭代器
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            // 集合元素是否符合条件
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

    // 返回一个顺序流
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    // 返回一个并行流
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

举例：

    @Test
    void collection() {
        List<Integer> integers = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        // replaceAll
        integers.replaceAll(integer -> integer + 1);
        System.out.println(integers);
        // sort
        integers.sort(Comparator.comparing(Integer::intValue));
        System.out.println(integers);
        // contains
        System.out.println(integers.contains(1));
        // containsAll
        System.out.println(integers.containsAll(Arrays.asList(1, 6)));
        // toArray
        System.out.println(Arrays.toString(integers.toArray(new Integer[0])));
        // removeIf
        integers.removeIf(integer -> integer == 1);
        System.out.println(integers);
        // retainAll
        integers.retainAll(List.of(2, 3, 6));
        System.out.println(integers);
        // stream
        Stream<Integer> stream = integers.stream();
        System.out.println(stream.count());
        // parallelStream
        System.out.println(integers.parallelStream().count());
    }

List/Set接口

List/Set继承关系

List/Set接口声明方法：

addAll(int index, Collection<? extends E> c)	从指定位置前方开始插入集合
replaceAll(UnaryOperator<E> operator)	执行operator操作，将结果替换每个元素（lambda）
sort(Comparator<? super E> c)	传入一个比较器进行排序（默认升序）
equals(Object o)	集合与集合进行比较
indexOf(Object o)	以下标0开始返回元素在集合中的位置，没有则返回-1（从前往后查)
lastIndexOf(Object o)	以下标0开始返回元素在集合中的位置，没有则返回-1（从后）
listIterator()	返回集合的迭代器，可添加对象，可顺序遍历和逆序遍历，可修改对象，可定位索引位置
listIterator(int index)	返回集合的迭代器，从指定位置开始
subList(int fromIndex, int toIndex)	返回集合的子范围视图（前包后不包）
copyOf(Collection<? extends E> coll)	复制一个不可修改集合

List的部分源码：

public interface List<E> extends Collection<E> {

    // 对集合的每个元素进行运算符操作后替换
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    // 排序（升序）
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    // 返回一个List迭代器
    ListIterator<E> listIterator();

    // 返回一个从下标index位置开始的List迭代器
    ListIterator<E> listIterator(int index);
}

举例：

    @Test
    void List_Set() {
        List<Integer> integers = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        // addAll
        integers.addAll(2, List.of(7, 8));
        System.out.println(integers);
        // equals
        System.out.println(integers.equals(List.of(2, 3, 1, 4, 5)));
        System.out.println(integers.equals(List.of(2, 3, 1, 4)));
        // indexOf
        System.out.println(integers.indexOf(3));
        System.out.println(integers.lastIndexOf(5));
        // listIterator
        ListIterator<Integer> listIterator = integers.listIterator();
        listIterator.add(6);
        System.out.println(integers);
        System.out.println(listIterator.next());
        listIterator.remove();
        System.out.println(integers);
        System.out.println(listIterator.next());
        System.out.println(listIterator.previousIndex());
        System.out.println(listIterator.previous());
        // listIterator(index)
        ListIterator<Integer> listIterator1 = integers.listIterator(2);
        listIterator1.forEachRemaining(System.out::println);
        // subList
        System.out.println(integers.subList(0, 2));
        // copyOf
        System.out.println(List.copyOf(integers));
    }

SortedSet接口

SortedSet继承关系

SortedSet接口声明方法：

comparator()	返回一个比较器（升序排列）
subSet(E fromElement, E toElement)	返回集的子范围视图（前包后不包）
headSet(E toElement)	返回此元素之前的元素集（不包括此元素）
tailSet(E fromElement)	返回此元素之后的元素集（包括此元素）
first()	获取集的第一个元素
last()	获取集的最后一个元素

TreeSet的部分源码：

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable {

    // TreeSet 使用 NavigableMap 来存储元素
    private transient NavigableMap<E,Object> m;

    // 返回 NavigableMap.comparato
    public Comparator<? super E> comparator() {
        return m.comparator();
    }

    // NavigableMap.subMap
    public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                                  E toElement,   boolean toInclusive) {
        return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                                       toElement,   toInclusive));
    }

    // NavigableMap.headMap
    public NavigableSet<E> headSet(E toElement, boolean inclusive) {
        return new TreeSet<>(m.headMap(toElement, inclusive));
    }

    // NavigableMap.tailMap
    public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
        return new TreeSet<>(m.tailMap(fromElement, inclusive));
    }

    public E first() {
        return m.firstKey();
    }

    public E last() {
        return m.lastKey();
    }
}

举例：

    @Test
    void SortSet() {
        // comparator
        SortedSet<Integer> integers = new TreeSet<>(new TreeSet<Integer>().comparator());
        integers.addAll(Arrays.asList(2, 1, 3, 4, 5, 6, 7));
        System.out.println(integers);
        // subSet
        Set<Integer> integersSet = integers.subSet(1, 3);
        System.out.println(integersSet);
        // headSet
        System.out.println(integers.headSet(4));
        // tailSet
        System.out.println(integers.tailSet(4));
        // first and Last
        System.out.println(integers.first());
        System.out.println(integers.last());
    }

NavigableSet接口

NavigableSet继承关系：

NavigableSet接口声明方法：

lower(E e)	集合与集合进行比较
floor(E e)	返回集中 <= 给定元素的最大元素，不存在则返回null
ceiling(E e)	返回集中 >= 给定元素的最小元素，不存在则返回null
higher(E e)	返回集中 > 给定元素的最小元素，不存在则返回null
pollFirst()	获取并移除第一个元素，若集为空返回null
pollLast()	获取并移除最后一个元素，若集为空返回null
descendingSet()	返回集的逆序视图
descendingIterator()	返回集的逆序迭代器

TreeSet的部分源码：

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable {

    // 返回集的逆序迭代器
    public Iterator<E> descendingIterator() {
        return m.descendingKeySet().iterator();
    }

    // 返回集的逆序视图
    public NavigableSet<E> descendingSet() {
        return new TreeSet<>(m.descendingMap());
    }
}

举例：

    @Test
    void NavigableSet() {
        NavigableSet<Integer> integers = new TreeSet<>(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8));
        // lower
        System.out.println(integers.lower(3));
        // floor
        System.out.println(integers.floor(3));
        // ceiling
        System.out.println(integers.ceiling(3));
        // higher
        System.out.println(integers.higher(3));
        // pollFirst
        System.out.println(integers.pollFirst());
        // pollLast
        System.out.println(integers.pollLast());
        // descendingSet()
        System.out.println(integers.descendingSet());
        // descendingIterator()
        integers.descendingIterator().forEachRemaining(System.out::print);
    }

Queue接口

Queue继承关系：

Queue接口声明方法：

add(E e)	队列添加元素，队列已满抛出异常IllegalStateException
offer(E e)	队列添加元素，队列已满返回false
remove()	从队列中删除第一个元素，元素为空抛出异常NoSuchElementException
poll()	从队列中删除第一个元素，元素为空返回null
element()	查询队列头部元素，元素为空抛出异常NoSuchElementException
peek()	查询队列头部元素，元元素为空返回null

举例：

    @Test
    void Queue() {
        Queue<Integer> integers = new ArrayDeque<>(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8));
        // add
        integers.add(9);
        System.out.println(integers);
        // offer
        integers.offer(10);
        // remove
        integers.remove();
        System.out.println(integers);
        // poll
        integers.poll();
        System.out.println(integers);
        // element
        integers.element();
        System.out.println(integers);
        // peek
        integers.peek();
        System.out.println(integers);
    }

Deque接口

Deque继承关系：

Deque接口声明方法：

addFirst(E e)/addLast(E e)	在双端队列的列头/列尾插入一个元素，队列已满抛出异常IllegalStateException
offerFirst(E e)/offerLast(E e)	在双端队列的列头/列尾插入一个元素，队列已满返回false
removeFirst()/removeLast()	在双端队列的列头/列尾删除一个元素，元素为空抛出异常NoSuchElementException
pollFirst()/pollLast()	在双端队列的列头/列尾删除一个元素，元素为空返回null
getFirst()/getLast()	在双端队列的列头/列尾查找一个元素，元素为空抛出异常NoSuchElementException
peekFirst()/peekLast()	在双端队列的列头/列尾查找一个元素，元素为空返回null
removeFirstOccurrence(Object o)	从此双端队列中删除指定元素的第一个匹配项
removeLastOccurrence(Object o)	从此双端队列中删除指定元素的最后一个匹配项
push(E e)	将一个元素压入以双端队列表示的堆栈
pop()	从此双端队列表示的堆栈中弹出一个元素
descendingIterator()	返回一个逆序的迭代器

举例：

    @Test
    void Deque() {
        Deque<Integer> integers = new ArrayDeque<>(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8));
        // addFirst/addLast
        integers.addFirst(-1);integers.addLast(9);
        System.out.println(integers);
        // offerFirst/offerLast
        integers.offerFirst(-2);integers.offerLast(10);
        // removeFirst/removeLast
        integers.removeFirst();integers.removeLast();
        System.out.println(integers);
        // pollFirst/pollLast
        integers.pollFirst();integers.pollLast();
        System.out.println(integers);
        // getFirst/getLast
        integers.getFirst();integers.getLast();
        System.out.println(integers);
        // peekFirst/peekLast
        integers.peekFirst();integers.peekLast();
        System.out.println(integers);
        // removeFirstOccurrence/removeLastOccurrence
        integers.removeFirstOccurrence(3);integers.removeLastOccurrence(5);
        System.out.println(integers);
        // push/pop
        integers.push(-3);integers.pop();
        System.out.println(integers);
    }