TreeMap<K, V>

TreeMap<K, V> 是 Java 集合框架中的一个重要类，它实现了 NavigableMap<K, V> 接口，而 NavigableMap<K, V> 继承自 SortedMap<K, V> 接口。下面将从多个方面详细介绍 TreeMap<K, V>。

特性

1. 键值对存储：TreeMap 以键值对（key - value）的形式存储数据，每个键都是唯一的，键不允许为 null，但值可以为 null。
2. 有序性：TreeMap 会根据键的自然顺序或者创建 TreeMap 时指定的比较器（Comparator）对键进行排序。如果键实现了 Comparable 接口，TreeMap 会使用键的自然顺序；如果在创建 TreeMap 时传入了 Comparator 对象，则使用该比较器定义的顺序。
3. 基于红黑树实现：红黑树是一种自平衡的二叉搜索树，这使得 TreeMap 在插入、删除和查找操作上的时间复杂度为 。

构造方法

1. TreeMap()：创建一个新的空 TreeMap，使用键的自然顺序进行排序。键必须实现 Comparable 接口。

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);
        System.out.println(map);
    }
}

1. TreeMap(Comparator<? super K> comparator)：创建一个新的空 TreeMap，使用指定的比较器进行排序。

import java.util.Comparator;
import java.util.TreeMap;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class TreeMapWithComparator {
    public static void main(String[] args) {
        Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);
        TreeMap<Person, Integer> map = new TreeMap<>(ageComparator);
        map.put(new Person("Alice", 25), 1);
        map.put(new Person("Bob", 20), 2);
        map.put(new Person("Charlie", 30), 3);
        System.out.println(map);
    }
}

1. TreeMap(Map<? extends K, ? extends V> m)：创建一个包含指定 Map 中所有键值对的 TreeMap，使用键的自然顺序进行排序。

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

public class TreeMapFromMap {
    public static void main(String[] args) {
        Map<String, Integer> anotherMap = new HashMap<>();
        anotherMap.put("apple", 1);
        anotherMap.put("banana", 2);
        TreeMap<String, Integer> map = new TreeMap<>(anotherMap);
        System.out.println(map);
    }
}

1. TreeMap(SortedMap<K, ? extends V> m)：创建一个包含指定 SortedMap 中所有键值对的 TreeMap，使用与指定 SortedMap 相同的比较器进行排序。

常用方法

1. 插入和更新操作put(K key, V value)：将指定的键值对插入到 TreeMap 中。如果键已经存在，则更新该键对应的值。返回该键之前关联的值，如果键不存在则返回 null。

TreeMap<String, Integer> map = new TreeMap<>();
Integer oldValue = map.put("apple", 1);

- **`putAll(Map<? extends K, ? extends V> m)`**：将指定 `Map` 中的所有键值对复制到当前 `TreeMap` 中。

Map<String, Integer> anotherMap = new HashMap<>();
anotherMap.put("banana", 2);
map.putAll(anotherMap);

1. 删除操作remove(Object key)：从 TreeMap 中移除指定键对应的键值对。返回该键关联的值，如果键不存在则返回 null。

Integer removedValue = map.remove("apple");

1. 查询操作get(Object key)：返回指定键关联的值，如果键不存在则返回 null。

Integer value = map.get("apple");

- **`containsKey(Object key)`**：判断 `TreeMap` 中是否包含指定的键，包含返回 `true`，否则返回 `false`。

boolean hasKey = map.containsKey("apple");

- **`containsValue(Object value)`**：判断 `TreeMap` 中是否包含指定的值，包含返回 `true`，否则返回 `false`。

boolean hasValue = map.containsValue(1);

- **`firstKey()`**：返回 `TreeMap` 中的第一个（最小的）键。

String firstKey = map.firstKey();

- **`lastKey()`**：返回 `TreeMap` 中的最后一个（最大的）键。

String lastKey = map.lastKey();

- **`ceilingKey(K key)`**：返回大于或等于给定键的最小键；如果不存在这样的键，则返回 `null`。

String ceilingKey = map.ceilingKey("apple");

- **`floorKey(K key)`**：返回小于或等于给定键的最大键；如果不存在这样的键，则返回 `null`。

String floorKey = map.floorKey("apple");

1. 遍历操作entrySet()：返回一个包含 TreeMap 中所有键值对的 Set 视图，每个键值对用 Map.Entry<K, V> 对象表示。遍历该 Set 可以按照键的排序顺序获取键值对。

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

public class TreeMapTraversal {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);

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

应用场景

1. 排序需求：当需要根据键的顺序对键值对进行排序时，TreeMap 是一个很好的选择。例如，按照日期排序的事件记录，按照字母顺序排序的单词统计等。
2. 范围查询：TreeMap 提供了一些方法用于进行范围查询，如 subMap()、headMap() 和 tailMap() 等，可以方便地获取指定范围的键值对。

注意事项

1. 键的比较：如果使用无参构造函数创建 TreeMap，键必须实现 Comparable 接口；如果使用带比较器的构造函数，则无需键实现 Comparable 接口。
2. 线程安全：TreeMap 不是线程安全的，如果需要在多线程环境下使用，可以考虑使用 ConcurrentSkipListMap 或通过 Collections.synchronizedSortedMap 方法将其包装成线程安全的集合。

import java.util.Collections;
import java.util.SortedMap;
import java.util.TreeMap;

SortedMap<String, Integer> synchronizedMap = Collections.synchronizedSortedMap(new TreeMap<>());

综上所述，TreeMap 是一个非常实用的集合类，适合需要对键进行排序和范围查询的场景。