JAVA集合类：List、Queue、Set、Map

在Java中，集合类是用于存储和操作大量数据的类，它们提供了一种组织和处理数据的有效方式。Java集合框架主要由两大接口派生：Collection 接口和 Map 接口。

Collection接口

Collection 接口是Java集合框架中最基本的接口，它是一个序列，可以容纳一组独立的元素。Collection 接口有以下几个主要的子接口：

1. List：一个有序的集合，可以包含重复的元素。提供了按索引位置存取元素的能力。主要实现类有 ArrayList、LinkedList 和 Vector。

2. Set：一个不允许重复的集合，每个元素都是唯一的。主要实现类有 HashSet、LinkedHashSet、TreeSet。

3. Queue：一个特殊的集合，遵循先进先出（FIFO）的原则。主要实现类有 LinkedList（用作队列）、PriorityQueue。

Collection 接口定义了一些通用的方法：

• boolean add(E e)：添加元素到集合中。
• boolean remove(Object o)：从集合中移除元素。
• int size()：返回集合中元素的数量。
• boolean isEmpty()：判断集合是否为空。
• Iterator<E> iterator()：返回集合的迭代器。

List接口示例（ArrayList）

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

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

        // 输出: List: [Apple, Banana, Cherry]
        System.out.println("List: " + list);

        // 获取并输出第二个元素
        String fruit = list.get(1); // 获取第二个元素
        // 输出: Fruit at index 1: Banana
        System.out.println("Fruit at index 1: " + fruit);

        // 删除元素并输出
        list.remove("Cherry");
        // 输出: List after removal: [Apple, Banana]
        System.out.println("List after removal: " + list);
    }
}

Set接口示例（HashSet）

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

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1); // 重复元素，不会被添加

        // 输出: Set: [1, 2, 3]
        System.out.println("Set: " + set);

        // 检查元素是否存在并输出
        boolean contains = set.contains(2);
        // 输出: Contains 2: true
        System.out.println("Contains 2: " + contains);
    }
}

Queue接口示例（LinkedList）

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("First");
        queue.offer("Second");

        // 输出: Queue: [First, Second]
        System.out.println("Queue: " + queue);

        // 移除并获取头部元素并输出
        String element = queue.poll();
        // 输出: Polled element: First
        System.out.println("Polled element: " + element);
        // 输出: Queue after poll: [Second]
        System.out.println("Queue after poll: " + queue);
    }
}

Map接口

Map 接口与 Collection 接口不同，它存储的是键值对（key-value pairs），而不是单独的元素。Map 提供了通过键快速查找、插入和删除元素的能力。Map 接口的主要实现类有：

1. HashMap：基于哈希表的 Map 接口实现，不保证映射的顺序。
2. LinkedHashMap：类似于 HashMap，但它维护了元素的插入顺序。
3. TreeMap：基于红黑树的 Map 接口实现，元素会按照键的自然顺序或自定义顺序进行排序。
4. Hashtable：和 HashMap 类似，但它是同步的，不允许空键和空值。

Map 接口定义了一些通用的方法：

• V put(K key, V value)：将指定的值与此映射中的指定键关联。
• V get(Object key)：返回指定键所映射的值。
• V remove(Object key)：如果存在一个键的映射关系，则将其从映射中移除。
• int size()：返回映射中的键-值映射关系数。
• boolean isEmpty()：判断映射是否为空。
• Set<K> keySet()：返回映射中包含的键的 Set 视图。
• Collection<V> values()：返回映射中包含的值的 Collection 视图。
• Set<Map.Entry<K, V>> entrySet()：返回映射中包含的键值映射关系的 Set 视图。

HashMap示例

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

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

        // 输出: Map: {Apple=1, Banana=2, Cherry=3}
        System.out.println("Map: " + map);

        // 通过键获取值并输出
        int value = map.get("Banana");
        // 输出: Value for 'Banana': 2
        System.out.println("Value for 'Banana': " + value);

        // 检查键是否存在并输出
        boolean containsKey = map.containsKey("Apple");
        // 输出: Contains key 'Apple': true
        System.out.println("Contains key 'Apple': " + containsKey);

        // 删除键值对并输出
        map.remove("Cherry");
        // 输出: Map after removal: {Apple=1, Banana=2}
        System.out.println("Map after removal: " + map);
    }
}

LinkedHashMap示例

import java.util.LinkedHashMap;
import java.util.Map;

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

        // 输出: LinkedHashMap: {Apple=1, Banana=2, Cherry=3}
        System.out.println("LinkedHashMap: " + map);

        // 遍历LinkedHashMap，保持插入顺序并输出
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            // 输出: Apple: 1
            // 输出: Banana: 2
            // 输出: Cherry: 3
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

TreeMap示例

import java.util.Map;
import java.util.TreeMap;

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

        // 输出: TreeMap: {Apple=1, Banana=2, Cherry=3}
        System.out.println("TreeMap: " + map);

        // 遍历TreeMap，按键的自然顺序并输出
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            // 输出顺序会按照键的自然顺序
            // 输出: Apple: 1
            // 输出: Banana: 2
            // 输出: Cherry: 3
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

总结

• Collection 接口用于存储一组独立的元素，可以是列表、集合或队列。
• Map 接口用于存储键值对，可以快速通过键来存取值。
• 选择使用 Collection 还是 Map 取决于你要解决的问题类型。

Java集合框架非常灵活，提供了丰富的接口和实现类，以满足不同的数据结构和算法需求。