Java双列集合

Map集合

Java Map集合是一种用于存储键值对的数据结构，它提供了从键到值的映射。其特点和常用操作如下：

1. 唯一性：Map中的键（key）必须是唯一的，这意味着不能有两个相同的键存在于同一个Map集合中。这是为了保证每个键都能准确地映射到一个值。
2. 空键：Map集合允许有一个键为null，但是只能有一个。这是因为null本身是唯一的，所以可以作为键存在。
3. 无序性：Map集合是无序的，它不保证元素的顺序。如果需要保持元素的插入顺序，可以使用LinkedHashMap；如果需要按键的自然顺序或者自定义顺序排序，可以使用TreeMap。
4. 常用方法：Map接口提供了一系列的方法来操作集合，例如put方法用于添加或更新键值对，get方法用于根据键获取值，remove方法用于删除键值对等。
5. 遍历方式：可以通过keySet()方法获取所有的键，然后遍历这些键来访问对应的值；也可以通过entrySet()方法获取包含所有键值对的集合，然后遍历这个集合来访问键和值。
6. 实现类：Java中Map接口的常用实现类包括HashMap、LinkedHashMap和TreeMap，它们分别提供了不同的特性和性能表现。

代码示例：

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

public class MapExample {
    public static void main(String[] args) {
        // 创建一个Map对象
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("apple", 10);
        map.put("banana", 20);
        map.put("orange", 30);

        // 获取键对应的值
        int value = map.get("banana");
        System.out.println("Value of banana: " + value);

        // 遍历Map中的键值对
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 移除键值对
        map.remove("orange");

        // 检查是否包含某个键
        boolean containsKey = map.containsKey("apple");
        System.out.println("Contains key 'apple': " + containsKey);

        // 获取所有键的集合
        Set<String> keys = map.keySet();
        System.out.println("All keys: " + keys);

        // 获取所有值的集合
        Collection<Integer> values = map.values();
        System.out.println("All values: " + values);
    }
}

HashMap

Java HashMap是Java集合框架中Map接口的一个重要实现，它允许使用键值对（key-value pairs）来存储和检索数据。以下是关于Java HashMap的一些关键点：

1. 快速访问：HashMap提供了快速的插入和查询操作，因为它基于哈希表实现。
2. 无序性：HashMap不保证元素的顺序。元素的排列顺序可能随着时间的推移发生变化，特别是在进行大量添加或删除操作后。
3. 空键和空值：HashMap允许有一个键为null，也允许有多个值为null。
4. 唯一性：虽然HashMap允许键为null，但它不允许有两个完全相同的键（根据equals方法判断）。
5. 初始化容量和加载因子：HashMap可以指定初始化容量（默认为16）和加载因子（默认为0.75）。当HashMap中的元素数量达到容量与加载因子的乘积时，它将自动扩容。
6. 散列冲突：HashMap使用散列函数来确定元素的存储位置。如果两个键的哈希码相同，它们会以链表或红黑树的形式存储在同一个桶中。
7. 线程不安全：HashMap不是线程安全的，如果在多线程环境中需要使用，可以考虑使用Collections.synchronizedMap方法来包装HashMap，或者使用ConcurrentHashMap。

以下是一个简单的HashMap示例代码：

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

public class HashMapExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例
        Map<String, Integer> map = new HashMap<>();

        // 向HashMap中添加元素
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // 获取HashMap中的元素
        int value = map.get("Two"); // 返回2

        // 遍历HashMap中的元素
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 移除HashMap中的元素
        map.remove("Three");

        // 检查HashMap是否包含某个键
        boolean containsKey = map.containsKey("One"); // 返回true

        // 获取HashMap的大小
        int size = map.size(); // 返回2

        // 清空HashMap
        map.clear();
    }
}

在这个示例中，我们创建了一个HashMap实例，并添加了一些键值对。然后，我们通过键来获取值，遍历了HashMap中的所有元素，并演示了如何移除元素、检查键是否存在、获取大小以及清空HashMap。

LinkedHashMap

Java LinkedHashMap是Java集合框架中Map接口的一个实现，它继承自HashMap类，并添加了链表来维护插入顺序。以下是关于Java LinkedHashMap的一些关键点：

1. 有序性：LinkedHashMap按照元素插入的顺序进行迭代，即第一个插入的元素在迭代时会先被访问。
2. 散列和链表：LinkedHashMap使用哈希表来存储键值对，同时使用双向链表来维护元素的插入顺序。当发生散列冲突时，元素会被存储在同一个桶中的链表中。
3. 空键和空值：LinkedHashMap允许有一个键为null，也允许有多个值为null。
4. 唯一性：虽然LinkedHashMap允许键为null，但它不允许有两个完全相同的键（根据equals方法判断）。
5. 线程不安全：LinkedHashMap不是线程安全的，如果在多线程环境中需要使用，可以考虑使用Collections.synchronizedMap方法来包装LinkedHashMap，或者使用ConcurrentHashMap。
6. 初始化容量和加载因子：LinkedHashMap可以指定初始化容量（默认为16）和加载因子（默认为0.75）。当LinkedHashMap中的元素数量达到容量与加载因子的乘积时，它将自动扩容。

以下是一个简单的LinkedHashMap示例代码：

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

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // 创建一个LinkedHashMap实例
        Map<String, Integer> map = new LinkedHashMap<>();

        // 向LinkedHashMap中添加元素
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // 获取LinkedHashMap中的元素
        int value = map.get("Two"); // 返回2

        // 遍历LinkedHashMap中的元素
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 移除LinkedHashMap中的元素
        map.remove("Three");

        // 检查LinkedHashMap是否包含某个键
        boolean containsKey = map.containsKey("One"); // 返回true

        // 获取LinkedHashMap的大小
        int size = map.size(); // 返回2

        // 清空LinkedHashMap
        map.clear();
    }
}

在这个示例中，我们创建了一个LinkedHashMap实例，并添加了一些键值对。然后，我们通过键来获取值，遍历了LinkedHashMap中的所有元素，并演示了如何移除元素、检查键是否存在、获取大小以及清空LinkedHashMap。

TreeMap

Java TreeMap是一个基于红黑树实现的Map接口，它保证了集合中的元素会按照一定的顺序进行存储。具体到TreeMap的特点和用法，可以分为以下几点：

1. 排序功能：TreeMap可以按照键的自然顺序或者自定义的比较器（Comparator）来对元素进行排序。这使得TreeMap在处理有序映射时非常有用。
2. 时间复杂度：由于TreeMap基于红黑树实现，因此它的put、get、containsKey、remove等操作的时间复杂度均为O(log(n))。
3. 不允许空值：TreeMap不允许键或值为null，这点与HashMap不同，后者允许一个键为null，也可以有多个值为null的条目。
4. 非同步：TreeMap不是线程安全的，因此在并发应用中需要额外注意或使用同步措施。
5. 继承关系：TreeMap实现了NavigableMap接口，并且继承了AbstractMap类，这意味着它支持返回给定搜索目标的最接近匹配项的方法。
6. 内部数据结构：TreeMap内部使用的数据结构是红黑树，这种数据结构能保证在插入和删除操作时保持较好的平衡，从而维持对数级的时间复杂度。

以下是一个简单的Java TreeMap代码示例：

import java.util.*;

public class TreeMapExample {
    public static void main(String[] args) {
        // 创建一个TreeMap实例，按照键的自然顺序排序
        TreeMap<Integer, String> treeMap = new TreeMap<>();

        // 向TreeMap中添加元素
        treeMap.put(3, "Three");
        treeMap.put(1, "One");
        treeMap.put(2, "Two");

        // 获取TreeMap中的元素
        String value = treeMap.get(2); // 返回"Two"

        // 遍历TreeMap中的元素
        for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 移除TreeMap中的元素
        treeMap.remove(1);

        // 检查TreeMap是否包含某个键
        boolean containsKey = treeMap.containsKey(3); // 返回true

        // 获取TreeMap的大小
        int size = treeMap.size(); // 返回2

        // 清空TreeMap
        treeMap.clear();
    }
}

在这个示例中，我们创建了一个TreeMap实例，并向其中添加了一些元素。然后，我们演示了如何获取、遍历、移除和清空TreeMap中的元素，以及如何检查TreeMap是否包含某个键和获取其大小。