Java基础 集合框架 Collection接口和抽象类AbstractCollection

集合框架

• Collection接口简介
• • 核心设计目标
  • • 父接口Iterable<T>
    • 基于Stream流的操作
    • 定义了所有集合类的基本操作
  • Collection接口方法
  • Collection接口总结
• 抽象类AbstractCollection简介
• • 核心设计目标
  • • 减少重复代码
    • [对 不可变集合 支持](#对 不可变集合 支持)
  • AbstractCollection关键方法实现
  • AbstractCollection在集合框架中的构造位置
  • AbstractCollection总结与使用注意事项

Collection接口简介

Collection接口是Java集合框架的根接口之一，它定义了所有集合类的基本操作，比如添加、删除、遍历元素等，另一个跟接口是Map

核心设计目标

父接口Iterable

public interface Collection<E> extends Iterable<E> {
    Iterator<E> iterator();
}

迭代Iterable接口以及迭代器Iterator介绍，Collection接口通过继承Iterable迭代接口实现以及返回Iterator方法实现普通检验迭代功能，这是Collection框架核心实现之一

但基于集合中各种集合列表的数据结构不同，具体的数据结构关于迭代功能又有具体的增强方式，比如子接口List提供了双向迭代器ListIterable，抽象类AbstractList有普通迭代器和增强迭代器，

Collection接口实现的普通迭代器只是提供基础迭代功能，即遍历和删除元素

基于Stream流的操作

    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }

Stream详细介绍，Collection接口提供了关于流的基础操作，流是Java 8 引入的，结合 Stream API 和 Lambda 表达式，实现高效数据处理。其中又分为串行流和并行流，而并行流的底层实现原理是分割迭代spliterator

定义了所有集合类的基本操作

它定义了所有集合类的基本操作，比如添加、删除、遍历元素等，如下Collection接口基础方法介绍功能

Collection接口方法

(1) 元素操作

方法	说明
boolean add(E e)	添加元素，成功返回 true（Set 中重复元素会返回 false）。
boolean remove(Object o)	删除指定元素，存在则返回 true。
boolean contains(Object o)	判断是否包含指定元素。

(2) 批量操作

方法	说明
boolean addAll(Collection<?> c)	添加另一个集合的所有元素。
boolean removeAll(Collection<?> c)	删除与另一集合的交集元素。
boolean retainAll(Collection<?> c)	仅保留与另一集合的交集元素。
void clear()	清空集合。

(3) 查询与转换

方法	说明
int size()	返回集合元素数量。
boolean isEmpty()	判断集合是否为空。
Object[] toArray()	将集合转换为数组。
<T> T[] toArray(T[] a)	将集合转换为指定类型的数组（更安全）。

(4) 迭代与遍历

方法	说明
Iterator<E> iterator()	返回迭代器，用于遍历集合。
default void forEach(Consumer<? super E> action)	Java 8+ 支持，使用 Lambda 遍历元素。

(5) Java 8+ 新增默认方法

方法	说明
default Stream<E> stream()	返回顺序流，支持 Stream API 操作。
default Stream<E> parallelStream()	返回并行流，支持多线程处理。

Collection接口总结

核心角色：Collection 是 Java 集合框架的基础，定义了单列集合的统一操作。

灵活扩展：通过子接口 List、Set、Queue 满足不同场景需求。

现代特性：结合 Stream API 和 Lambda 表达式，实现高效数据处理。

抽象类AbstractCollection简介

AbstractCollection是Java集合框架中为 Collection 接口提供骨架实现的核心抽象类，旨在简化集合类的开发

核心设计目标

减少重复代码

复用代码 减少开发

抽象类 AbstractCollection是集合框架中为 Collection 接口的通用方法提供默认实现（如 contains()、isEmpty()、remove() 等），开发者需实现关键抽象方法 iterator() 和 size() 即可创建集合类

public abstract class AbstractCollection<E> implements Collection<E> {

	//未实现具体功能需要具体子类实现的关键抽象方法iterator()和size()
    public abstract Iterator<E> iterator();
    public abstract int size();

	//通用方法提供默认实现的部分方法示例如下
	public boolean isEmpty() {
     return size() == 0;
    }
   public boolean contains(Object o) {
			`````````
    }
	
}

多种集合结构模式，实现多态机制

为了减少开发代码为什么不干脆为所有的方法都提供默认功能实现，还保留两个抽象方法要具体子类实现，是因为不同容器类型结构不同的原因，这就涉及到有序 无序 队列等多种结构模式，而集合底层的实现是依靠迭代器的管理的，不同的结构迭代方式不同，才有了两个核心抽象方法由具体的子类（具体的结构模式）去实现

public class ImmutableCollection<E> extends AbstractCollection<E> {
	//比如数据结构是数组形式的集合结构，那迭代器和容器元素大小都基于数组特性实现
    private E[] elements;

    @Override
    public Iterator<E> iterator() { return Arrays.stream(elements).iterator(); }

    @Override
    public int size() { return elements.length; }
}

对 不可变集合 支持

伪实现的方法 如add()，add没有设计成抽象方法 是为了提供一个有用的默认行为(抛出不可操作异常)，更容易实现对不可修改的集合操作管理

	//伪实现的方法 如果不重写add方法直接调用 会直接抛出不支持操作异常
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

首先什么是不可变集合
不可修改集合是指集合一旦创建，其内容就不能被修改，包括添加、删除或修改元素，并不是final修饰的就是不可变集合

    public static void main(String[] args) {
        final int[] scores = new int[5];
        scores[0] = 1;//没有报错 依然可以修改添加元素
        int[] tempArray = {90, 70, 50, 80, 60, 85};
        scores = tempArray; // 静态编译报错提示 不可以使用final修饰

        final List<String> list = new ArrayList<>();
        list.add("a");//没有报错 依然可以添加元素
        list = new ArrayList<>(); //静态编译报错提示 不可以使用final修饰
    }

final变量用法，修饰类和方法表示类不可以继承，方法不可以重写，修饰变量表示不可以更改，如果修饰的是对象表示对象的引用不可以更改，这里修饰的数组和list对象都表示不可以更改引用，所以重新指向引用就报错了，但是对集合中的元素还是可以进行操作修改的

为什么需要 不可变集合
集合是存储元素，在特定的情况下我们需要控制不可以改变集合中元素的内容，如多线程下的安全性，比如哈希码值我们希望能作为常量不可以改变，又或者性能优化不可变的集合可节省空间和时间的开销

        List<String> list = Stream.of("张三", "李四", "王五", "赵六").collect(Collectors.toList());
        // java 1.8实现不可变集合方法
        List<String> immutableList = Collections.unmodifiableList(list);
        immutableList.add("a");//执行到这里抛出不可操作异常UnsupportedOperationException


       //JDK9+ 之后 可以使用 List.of方法 更简单些
        //不可变List集合
        List<Double> lists = List.of(140.5, 120.0, 95.5, 70.5, 80.0); //
        lists.add(123.0); //运行报错 UnsupportedOperationException  不可变
        lists.set(0,140.0); //报错

        //不可变set集合
        //Set<String> sets = Set.of("a", "b", "d", "c","a"); // a 不允许重复 直接报错
        Set<String> sets = Set.of("a", "b", "d", "c");
        sets.add("a"); //报错

        //不可变Map集合
        Map<String,Integer> maps = Map.of("a",100,"b",200,"c",300);
        maps.put("d",200); //报错

add方法并没有被设计成抽象方法，而是提供了一个默认的实现，这个默认实现是抛出一个UnsupportedOperationException异常。通过提供一个默认的异常抛出行为，AbstractCollection.add(E)使得开发者在实现不可修改的集合时更加方便。如果add方法被设计成抽象方法，那么每一个继承自AbstractCollection的类都必须提供一个add方法的实现，这可能会导致一些不必要的复杂性

AbstractCollection关键方法实现

方法	实现逻辑	依赖的抽象方法
contains(Object)	遍历迭代器，逐个比较元素是否相等（支持 null 检查）	iterator()
toArray()	创建新数组，通过迭代器填充元素	iterator(), size()（优化提示）
remove(Object)	遍历迭代器查找元素，调用迭代器的 remove() 删除，但迭代器的 remove() 方法 也是默认抛出 UnsupportedOperationException，所以也需子类重写以实现 可修改集合	iterator()
isEmpty()	直接调用 size() == 0	size()
add(E)	默认抛出 UnsupportedOperationException，需子类重写以实现 可修改集合	-

AbstractCollection在集合框架中的构造位置

• 父类关系 ：实现 集合框架两大根接口之一的Collection接口、提供默认通用模板方法
• 子类关系 ：AbstractList、AbstractSet、AbstractQueue等均继承 AbstractCollection，进一步细化列表、集合的特性

AbstractCollection总结与使用注意事项

总结：

• 模板方法模式 ：通过抽象方法 iterator() 和 size() 定义算法框架，具体实现延迟到子类。例如，contains() 的遍历逻辑固定，但元素访问方式由子类决定。
• 代码复用 ：所有集合共享通用方法（如 toString() 生成 [a, b, c] 格式字符串），避免重复实现。
• 扩展性 ：子类可选择性重写方法以优化性能（如 ArrayList 直接通过索引实现 contains()，比迭代遍历更高效）

注意事项:

• 方法限制 ：默认 add() 和 remove() 可能抛出 UnsupportedOperationException，需根据集合类型重写。
• 性能考量 ：通用方法如 containsAll() 通过迭代实现，数据量大时可能效率低下，子类可优化
• 并发问题 ：AbstractCollection并没有特殊表明多线程下安全管理，所以是非线程安全的，多线程环境需外部同步或使用并发集合类。