一、核心区别

        Collection：是接口，Java 集合框架的根接口之一，定义了 List、Set、Queue 等单值集合的通用规范（存、取、删、遍历等）

        Collections：是工具类，全是静态方法（意味着只需要调用即可，不需要创建对象），专门用来对 Collection 集合进行排序、查找、同步、不可变等便捷操作。

        形象一点说：Collection是说明书，规定集合该有哪些功能；Collections是工具，给集合提供操作

        可以用一张表来清晰的看出区别：

二、Collection接口

1.继承体系

   java.util.Collection 是 Java 集合框架的顶层父接口，继承了 Iterable 接口（意味着所有 Collection 集合都支持迭代遍历）。

        它是List、Set、Queue 的父接口，但是需要注意的是Map不属于Collection，Map是双值集合（存储键值对），独立于Collection体系

        完整继承结构如下：

Iterable（迭代器接口）
  ↓
Collection（集合顶层接口）
  ├─ List（有序、可重复、索引访问）
  ├─ Set（无序、不可重复）
  └─ Queue（队列、先进先出）

2.核心作用

        Collection 定义了所有单值集合必须实现的通用方法，统一了集合的操作规范。无论你用 ArrayList、HashSet 还是 LinkedList，都能通过 Collection 接口调用通用方法，实现面向接口编程。

3.常用方法

        Collection没有提供实现类，而是定义了以下核心方法，由List、Set、Queue自行实现，常用实现类有：

• List：ArrayList、LinkedList、Vector
• Set：HashSet、LinkedHashSet、TreeSet
• Queue：LinkedList、PriorityQueue

// 添加元素
boolean add(E e);
// 批量添加
boolean addAll(Collection<? extends E> c);
// 删除指定元素
boolean remove(Object o);
// 判断是否包含
boolean contains(Object o);
// 清空集合
void clear();
// 获取元素个数
int size();
// 判断是否为空
boolean isEmpty();
// 转数组
Object[] toArray();
// 迭代器（遍历集合）
Iterator<E> iterator();

4.代码示例

        Collection引用指向ArrayList实现类：

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();

        // 1. 添加元素
        collection.add("Java");
        collection.add("Python");
        collection.add("C++");
        System.out.println("添加后：" + collection); // [Java, Python, C++]

        // 2. 判断元素是否存在
        System.out.println("包含Java？" + collection.contains("Java")); // true

        // 3. 获取集合大小
        System.out.println("集合大小：" + collection.size()); // 3

        // 4. 移除元素
        collection.remove("C++");
        System.out.println("移除后：" + collection); // [Java, Python]

        // 5. 遍历集合（迭代器）
        for (String s : collection) {
            System.out.println("遍历元素：" + s);
        }

        // 6. 清空集合
        collection.clear();
        System.out.println("清空后是否为空：" + collection.isEmpty()); // true
    }
}

三、Collections工具类

1.定义与特点   

  java.util.Collections 是 Java 提供的集合工具类，构造方法私有（private Collections(){}），不能实例化，所有方法都是静态方法，直接通过类名调用。

        它的核心作用：简化集合操作，提供原生集合没有的高级功能（排序、反转、查找、同步、不可变等）。

2.常用静态方法

（1）排序

        这里的comparator之前有提到过哦！在lambda那篇文章里

// 自然排序（元素必须实现Comparable）
Collections.sort(list);
// 自定义排序（传入Comparator）
Collections.sort(list, Comparator.comparing(...) );

（2）查找

// 二分查找（必须先排序）
int index = Collections.binarySearch(list, key);
List<Integer> list = new ArrayList<>();
//获取最大值
Integer max = Collections.max(list); 
//获取最小值
Integer min = Collections.min(list);

（3）修改

// 反转集合
Collections.reverse(list);
// 随机打乱
Collections.shuffle(list);
// 替换所有元素
Collections.fill(list, obj);
// 交换两个索引位置
Collections.swap(list, i, j);

（4）线程安全转换

   Collection<T> synchronizedCollection(Collection<T> c)：将非线程安全集合转为线程安全集合

   List<T> synchronizedList(List<T> list)：线程安全 List

   Set<T> synchronizedSet(Set<T> s)：线程安全 Set

3.代码示例

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(30);
        list.add(10);
        list.add(20);
        list.add(50);
        System.out.println("原始集合：" + list); // [30, 10, 20, 50]

        // 1. 升序排序
        Collections.sort(list);
        System.out.println("排序后：" + list); // [10, 20, 30, 50]

        // 2. 反转集合
        Collections.reverse(list);
        System.out.println("反转后：" + list); // [50, 30, 20, 10]

        // 3. 获取最大/最小值
        System.out.println("最大值：" + Collections.max(list)); // 50
        System.out.println("最小值：" + Collections.min(list)); // 10

        // 4. 二分查找（需先排序）
        Collections.sort(list);
        System.out.println("查找20的索引：" + Collections.binarySearch(list, 20)); // 1

        // 5. 随机打乱
        Collections.shuffle(list);
        System.out.println("随机打乱后：" + list);

        // 6. 转为不可变集合（增删抛 UnsupportedOperationException）
        List<Integer> unmodifiableList = Collections.unmodifiableList(list);
        // unmodifiableList.add(60); // 运行报错

        // 7. 转为线程安全集合
        List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
    }
}

四、常见误区

误区 1：把 Collections 当作集合使用：

        错误：Collections list = new ArrayList();

        正确：Collection list = new ArrayList();

误区 2：用 Collection 做排序 / 查找

        Collection 接口没有排序方法，排序必须用 Collections.sort()。

误区 3：认为 Collections 是 Collection 的实现类

        二者无继承关系，Collections 是独立的工具类，和 Collection 接口没有父子关系。

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2401_87174643/article/details/159887222