JAVA中的Collection集合及ArrayList,LinkedLIst,HashSet,TreeSet和其它实现类的常用方法

前言

Collection 是 Java 中的一个接口，定义了所有集合类的通用操作。它是所有单一元素集合类（如 List、Set）的父接口。Collection 接口包括一些常用的方法，并且其不同的实现类（如 ArrayList、HashSet 等）可能会扩展出一些额外的方法。

一、Collection 接口常用方法

这些方法所有Collection实现类都可以使用。
ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet集合都可以调用下面的方法。

下面，我们以 ArrayList 为例，解释 Collection 接口中的常用方法。

1.boolean add(E e)

向 ArrayList 中添加一个元素。如果成功添加，返回 true。

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list);  // 输出：[Apple, Banana]

2.boolean remove(Object o)

从 ArrayList 中移除指定的元素。如果成功移除，返回 true。

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.remove("Apple");  // 移除元素"Apple"
System.out.println(list);  // 输出：[Banana]

注意
对于 List 接口（如 ArrayList, LinkedList）
调用 remove(Object o) 时，只会删除第一个匹配的元素

对于 Set 接口（如 HashSet, TreeSet）
不允许重复元素，所以不会有多个相同的元素

3.boolean contains(Object o)

判断 ArrayList 中是否包含指定的元素。返回 true 如果存在，false 如果不存在。

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list.contains("Apple"));  // 输出：true
System.out.println(list.contains("Grape"));  // 输出：false

4.boolean isEmpty()

检查 ArrayList 是否为空。如果集合中没有任何元素，返回 true，否则返回 false。

ArrayList<String> list = new ArrayList<>();
System.out.println(list.isEmpty());  // 输出：true
list.add("Apple");
System.out.println(list.isEmpty());  // 输出：false

5.int size()

返回 ArrayList 中元素的数量

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list.size());  // 输出：2

6.void clear()

清空 ArrayList 中的所有元素

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.clear();  // 清空集合
System.out.println(list);  // 输出：[]

7.Object[] toArray()

将 ArrayList 转换为一个包含所有元素的数组

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
Object[] array = list.toArray();
for (Object obj : array) {
    System.out.println(obj);  // 输出：Apple  Banana
}

8.boolean containsAll(Collection<?> c)

判断 ArrayList 是否包含指定集合中的所有元素。

ArrayList<String> list1 = new ArrayList<>();
list1.add("Apple");
list1.add("Banana");

ArrayList<String> list2 = new ArrayList<>();
list2.add("Apple");

System.out.println(list1.containsAll(list2));  // 输出：true

9.boolean addAll(Collection<? extends E> c)

将指定集合中的所有元素添加到 ArrayList 中。

ArrayList<String> list1 = new ArrayList<>();
list1.add("Apple");
list1.add("Banana");

ArrayList<String> list2 = new ArrayList<>();
list2.add("Orange");
list2.add("Grape");

list1.addAll(list2);  // 添加list2中的所有元素到list1
System.out.println(list1);  // 输出：[Apple, Banana, Orange, Grape]

10.boolean removeAll(Collection<?> c)

移除 ArrayList 中与指定集合相同的所有元素。

ArrayList<String> list1 = new ArrayList<>();
list1.add("Apple");
list1.add("Banana");
list1.add("Orange");

ArrayList<String> list2 = new ArrayList<>();
list2.add("Apple");
list2.add("Orange");

list1.removeAll(list2);  // 移除list1中与list2相同的元素
System.out.println(list1);  // 输出：[Banana]

11.boolean retainAll(Collection<?> c)

保留 ArrayList 中仅包含指定集合中的元素，移除其他元素。

ArrayList<String> list1 = new ArrayList<>();
list1.add("Apple");
list1.add("Banana");
list1.add("Orange");

ArrayList<String> list2 = new ArrayList<>();
list2.add("Apple");
list2.add("Grape");

list1.retainAll(list2);  // 保留list1中与list2相同的元素
System.out.println(list1);  // 输出：[Apple]

12.Iterator iterator()

返回一个 Iterator 迭代器，用于遍历 ArrayList 中的元素。

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());  // 输出：Apple  Banana
}

Java 8 开始在 Collection 接口中引入

13.forEach(Consumer<? super E> action)

14.removeIf(Predicate<? super E> filter)

二、Collection 实现接口/类拓展方法

1.List 接口的其他通用方法

List 接口的实现类（如 ArrayList 和 LinkedList）也提供了许多扩展方法

以Arraylist为例

add(int index, E element)

在指定位置添加元素。

List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana"));
list.add(1, "Orange");  // 在索引1的位置添加元素
System.out.println(list);  // 输出：[Apple, Orange, Banana]

remove(int index)

移除指定位置的元素。

List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange"));
list.remove(1);  // 移除索引1的元素
System.out.println(list);  // 输出：[Apple, Orange]

set(int index, E element)

在指定位置更新元素。

List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange"));
list.set(1, "Mango");  // 替换索引1的元素
System.out.println(list);  // 输出：[Apple, Mango, Orange]

get(int index)

获取指定索引位置的元素。

List<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange"));
System.out.println(list.get(1));  // 输出：Banana

forEach(Consumer<? super E> action)

对 List 中的每个元素执行指定的操作。

ArrayList<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange"));
list.forEach(System.out::println);  // 输出：Apple, Banana, Orange

removeIf(Predicate<? super E> filter)

删除集合中符合条件的所有元素。

ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
numbers.removeIf(n -> n % 2 == 0);  // 删除所有偶数
System.out.println(numbers);  // 输出：[1, 3, 5]

2.LinkedList 类的扩展方法

LinkedList 是基于双向链表实现的 List 接口实现，它不仅可以作为 List 使用，还支持 Deque（双端队列）的一些操作。

addFirst(E e)

将元素插入到链表的头部。

LinkedList<String> list = new LinkedList<>();
list.addFirst("Apple");
list.addFirst("Banana");
System.out.println(list);  // 输出：[Banana, Apple]

addLast(E e)

将元素添加到链表的尾部。

LinkedList<String> list = new LinkedList<>();
list.addLast("Apple");
list.addLast("Banana");
System.out.println(list);  // 输出：[Apple, Banana]

getFirst()

返回链表头部的元素。如果链表为空，抛出 NoSuchElementException。

LinkedList<String> list = new LinkedList<>(Arrays.asList("Apple", "Banana"));
System.out.println(list.getFirst());  // 输出：Apple

getLast()

返回链表尾部的元素。如果链表为空，抛出 NoSuchElementException。

LinkedList<String> list = new LinkedList<>(Arrays.asList("Apple", "Banana"));
System.out.println(list.getLast());  // 输出：Banana

removeFirst()

移除并返回链表头部的元素。如果链表为空，抛出 NoSuchElementException。

LinkedList<String> list = new LinkedList<>(Arrays.asList("Apple", "Banana"));
System.out.println(list.removeFirst());  // 输出：Apple
System.out.println(list);  // 输出：[Banana]

removeLast()

移除并返回链表尾部的元素。如果链表为空，抛出 NoSuchElementException

LinkedList<String> list = new LinkedList<>(Arrays.asList("Apple", "Banana"));
System.out.println(list.removeLast());  // 输出：Banana
System.out.println(list);  // 输出：[Apple]

3.Set 集合forEach(),removeIf()方法

HashSet

HashSet 基于哈希表实现，集合中的元素是无序的且不允许重复。

forEach(Consumer<? super E> action)

forEach 遍历集合并执行指定操作。

HashSet<String> set = new HashSet<>(Arrays.asList("Apple", "Banana"));
set.forEach(System.out::println);  // 输出：Apple, Banana（顺序不确定）

removeIf(Predicate<? super E> filter)

从 HashSet 中移除满足 Predicate 条件的元素。

HashSet<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4));
set.removeIf(n -> n % 2 == 0);  // 移除偶数
System.out.println(set);  // 输出：[1, 3]

LinkedHashSet

LinkedHashSet 基于哈希表实现，但它还维护了插入顺序，遍历时按照元素的插入顺序返回。

forEach(Consumer<? super E> action)

与 HashSet 类似，但因为 LinkedHashSet 维护了元素的插入顺序，所以遍历时元素的顺序是可预测的。

LinkedHashSet<String> set = new LinkedHashSet<>(Arrays.asList("Apple", "Banana"));
set.forEach(System.out::println);  // 输出：Apple, Banana

removeIf(Predicate<? super E> filter)

移除符合条件的元素，操作和 HashSet 相同。

LinkedHashSet<Integer> set = new LinkedHashSet<>(Arrays.asList(1, 2, 3, 4));
set.removeIf(n -> n % 2 == 0);  // 移除偶数
System.out.println(set);  // 输出：[1, 3]

TreeSet

TreeSet 是基于红黑树实现的 Set，它的元素是有序的并且不允许重复。

forEach(Consumer<? super E> action)

forEach 与其他集合类类似，遍历元素时遵循元素的自然顺序或指定的比较器顺序。

TreeSet<Integer> set = new TreeSet<>(Arrays.asList(5, 1, 3, 2, 4));
set.forEach(System.out::println);  // 输出：1, 2, 3, 4, 5

removeIf(Predicate<? super E> filter)

与其他集合类类似

TreeSet<Integer> set = new TreeSet<>(Arrays.asList(1, 2, 3, 4));
set.removeIf(n -> n % 2 == 0);  // 移除偶数
System.out.println(set);  // 输出：[1, 3]

4.Set 集合在自定义类中重写 equals() 和 hashCode() 方法保证元素不重复

假设我们有一个 Person 类，想要把多个 Person 对象存储到 Set 集合中，并且确保 Set 中的 Person 对象不重复。

import java.util.HashSet;
import java.util.Set;
import java.util.Objects;

class Person {
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写 equals() 方法，确保对象的值相同才被认为相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    // 重写 hashCode() 方法，确保相等的对象有相同的 hashCode
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    // 重写 toString() 方法，方便输出
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

public class SetExample {
    public static void main(String[] args) {
        // 创建一个 Set 集合
        Set<Person> set = new HashSet<>();

        // 添加元素
        set.add(new Person("Alice", 25));
        set.add(new Person("Bob", 30));
        set.add(new Person("Alice", 25));  // 添加重复元素

        // 输出集合内容
        System.out.println(set);  // 输出: [Person{name='Alice', age=25}, Person{name='Bob', age=30}]
    }
}

总结

Collection 接口定义了集合类通用的方法，这些方法在不同的集合实现类中都有所体现。不同的实现类提供了不同的存储和访问方式，适合不同的业务场景，实现类的扩展方法也为 Java 集合框架提供了更强大的功能。