【Java基础——20 常用集合】

ava 中的集合框架提供了多种集合类和接口，用于存储和操作数据。以下是你提到的一些关键集合类和接口的详细介绍：

1. HashSet 集合类

HashSet 是一个基于哈希表的集合类，它不保证集合的迭代顺序。HashSet 允许存储 null 元素，并且不允许重复的元素。

主要特点：

• 无序性：不保证元素的顺序。
• 唯一性：不允许重复元素。
• 性能：由于使用哈希表，插入、删除和查找操作的时间复杂度为 O(1)。

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple"); // 重复元素不会被添加

        for (String item : set) {
            System.out.println(item);
        }
    }
}

2. LinkedHashSet 集合类

LinkedHashSet 是 HashSet 的一个子类，它具有哈希表和链表的性质。它保证迭代时按插入顺序排列元素。

主要特点：

• 有序性：按插入顺序排列元素。
• 唯一性：不允许重复元素。
• 性能：插入、删除和查找操作的时间复杂度为 O(1)，但由于维护链表，性能略低于 HashSet。

import java.util.LinkedHashSet;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple"); // 重复元素不会被添加

        for (String item : set) {
            System.out.println(item);
        }
    }
}

TreeSet

TreeSet 保证元素的有序性，并提供了比其他集合类更高效的集合操作。它的主要特点是：

1. 有序性：TreeSet 中的元素根据其自然顺序或根据提供的比较器排序。
2. 唯一性：TreeSet 不允许重复元素。
3. 性能：TreeSet 的基本操作（添加、删除和查找）的时间复杂度为 O(log n)，因为它是基于红黑树（self-balancing binary search tree）实现的。

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("Banana");
        set.add("Apple");
        set.add("Orange");
        set.add("Apple"); // 重复元素不会被添加

        // 遍历元素
        for (String item : set) {
            System.out.println(item);
        }

        // 检查是否包含某个元素
        boolean containsBanana = set.contains("Banana");
        System.out.println("Contains Banana: " + containsBanana);

        // 获取第一个和最后一个元素
        String first = set.first();
        String last = set.last();
        System.out.println("First: " + first + ", Last: " + last);

        // 获取子集
        TreeSet<String> subset = (TreeSet<String>) set.subSet("Apple", "Orange");
        System.out.println("Subset: " + subset);
    }
}

3. Collections 集合工具类

Collections 是一个包含各种静态方法的类，这些方法用于操作或返回集合。它提供了排序、搜索、线程安全化等实用工具。

主要功能：

• 排序：如 Collections.sort(List<T> list)。
• 搜索：如 Collections.binarySearch(List<? extends Comparable<? super T>> list, T key)。
• 线程安全化：如 Collections.synchronizedList(List<T> list)。

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

public class CollectionsExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Banana");
        list.add("Apple");
        list.add("Orange");

        Collections.sort(list); // 排序

        for (String item : list) {
            System.out.println(item);
        }
    }
}

4. Map 接口

Map 是一个接口，它映射唯一键到特定的值。常用的实现类包括 HashMap、TreeMap 和 LinkedHashMap。

主要特点：

• 键值对存储：每个键映射到一个值。
• 键的唯一性：不允许重复键，但允许重复值。

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Orange", 3);

        System.out.println(map.get("Apple")); // 输出 1
    }
}

Map 集合的遍历方式

Map 的遍历方式有多种，主要包括：

1. 通过 keySet() 方法：

for (String key : map.keySet()) {
    System.out.println("Key: " + key + ", Value: " + map.get(key));
}

1. 通过 entrySet() 方法：

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

1. 通过 values() 方法：

for (Integer value : map.values()) {
    System.out.println("Value: " + value);
}

5. 队列（Queue）

队列是一种先进先出（FIFO，First-In-First-Out）的数据结构，元素按照加入的顺序排列，最先加入的元素最先被移除。

常见的队列实现类：

• LinkedList：Java 中的 LinkedList 类实现了 Queue 接口，可以作为队列使用。

• ArrayDeque：ArrayDeque 类也实现了 Queue 接口，底层使用数组实现。

主要方法和特性：

• offer(E e)：向队列尾部添加一个元素，并返回 true；如果队列已满，则返回 false。
• poll()：移除并返回队列头部的元素；如果队列为空，则返回 null。
• peek()：返回队列头部的元素，但不移除；如果队列为空，则返回 null。
• isEmpty()：判断队列是否为空。
• size()：返回队列中的元素数量。

• LinkedList：

  • java.util.LinkedList 实现了 Queue 接口，可以作为队列使用。它既可以作为队列，也可以作为双端队列（Deque）使用。
  • 示例：

• Queue<String> queue = new LinkedList<>();
  queue.offer("item1");
  queue.offer("item2");
  String item = queue.poll(); // 出队列
  

• ArrayDeque：

  • java.util.ArrayDeque 是一个双端队列的实现，也可以用作队列。它比 LinkedList 更高效，因为使用了数组来存储元素。
  • 示例：

• Queue<String> queue = new ArrayDeque<>();
  queue.offer("item1");
  queue.offer("item2");
  String item = queue.poll(); // 出队列
  

• PriorityQueue：

  • java.util.PriorityQueue 是一个优先级队列，它不是严格的先进先出队列，而是根据元素的优先级进行排序。
  • 示例：

• Queue<Integer> queue = new PriorityQueue<>();
  queue.offer(3);
  queue.offer(1);
  queue.offer(2);
  int item = queue.poll(); // 出队列，会返回最小的元素
  

6. 栈（Stack）

栈是一种后进先出（LIFO，Last-In-First-Out）的数据结构，最后加入的元素最先被移除。

Java 中的栈实现：

• Stack 类：Java 提供了 java.util.Stack 类来实现栈。
• ArrayDeque

主要方法和特性：

• push(E item)：将元素推入栈顶。
• pop()：移除并返回栈顶的元素。
• peek()：返回栈顶的元素，但不移除。
• isEmpty()：判断栈是否为空。
• search(Object o)：返回元素在栈中的位置，以 1 开始计数；如果不存在，则返回 -1。

• Stack：

  • java.util.Stack 是 Java 提供的经典栈的实现类，它继承自 Vector 类，因此是一个线程安全的类，但在性能上不如 ArrayDeque。
  • 示例：

  • Stack<String> stack = new Stack<>();
    stack.push("item1");
    stack.push("item2");
    String item = stack.pop(); // 出栈
    

• ArrayDeque：

  • java.util.ArrayDeque 也可以用作栈的实现，它同样支持在栈顶进行元素的入栈和出栈操作，并且比 Stack 更高效。
  • 示例：

  • Deque<String> stack = new ArrayDeque<>();
    stack.push("item1");
    stack.push("item2");
    String item = stack.pop(); // 出栈