Java中的SortedMap接口及示例

SortedMap是集合框架中的一个接口。该接口扩展了Map接口，并对其元素提供了完全有序的排序（可以按键的排序顺序遍历元素）。实现这个接口的类是TreeMap。

SortedMap接口是Java中java.util.Map接口的子接口。它扩展了Map接口，基于其键的自然顺序，为其元素提供了完全有序的排序。

SortedMap和普通Map之间的主要区别在于，SortedMap中的元素按照有序顺序存储，而在Map中，元素按任意顺序存储。排序顺序由键的自然顺序决定，这些键必须实现java.lang.Comparable接口，或者由传递给SortedMap构造函数的Comparator决定。

这里是如何使用SortedMap接口的示例：

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

public class Main {
    public static void main(String[] args) {
        SortedMap<String， Integer> sortedMap = new TreeMap<>（）;

        //向有序映射中添加元素
        sortedMap.put("A", 1);
        sortedMap.put("C", 3);
        sortedMap.put("B", 2);

        //从有序映射中获取值
        int valueA = sortedMap.get("A");
        System.out.println("A的值：" + valueA);

        //从有序映射中删除元素
        sortedMap.remove("B");

        //遍历有序映射的元素
        for (String key : sortedMap.keySet()) {
            System.out.println("键：" + key + ", 值：" + sortedMap.get(key));
        }
    }
}

输出

A的值: 1
键：A，值：1
键：C，值：3

Java中的SortedMap接口及示例

SortedMap的主要特点是按照其自然顺序或指定的比较器对键进行排序。因此，在以下情况下，请考虑使用TreeMap来满足以下条件的映射：

不允许空键或空值。
键以自然顺序或指定比较器方式排序。

类型参数：

键的类型。
映射值的类型。

SortedMap的父接口是Map<K， V>。

SortedMap的子接口是ConcurrentNavigableMap<K， V>和NavigableMap<K， V>。

SortedMap的实现是ConcurrentSkipListMap和TreeMap。

声明：

public interface SortedMap<K, V> extends Map<K, V>
{
    Comparator comparator();
    SortedMap subMap(K fromKey, K toKey);
    SortedMap headMap(K toKey);
    SortedMap tailMap(K fromKey);
    K firstKey();
    K lastKey();
}

示例：

// Java代码示例演示SortedMap接口
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
 
public class SortedMapExample {
    public static void main(String[] args)
    {
        SortedMap<Integer, String> sm
            = new TreeMap<Integer, String>();
        sm.put(new Integer(2), "practice");
        sm.put(new Integer(3), "quiz");
        sm.put(new Integer(5), "code");
        sm.put(new Integer(4), "contribute");
        sm.put(new Integer(1), "geeksforgeeks");
        Set s = sm.entrySet();
 
        // 在SortedMap中使用迭代器
        Iterator i = s.iterator();
 
        // 遍历映射。请注意，遍历输出是排序的（按键）。
        while (i.hasNext()) {
            Map.Entry m = (Map.Entry)i.next();
 
            int key = (Integer)m.getKey();
            String value = (String)m.getValue();
 
            System.out.println("Key : " + key
                               + "  value : " + value);
        }
    }
}

输出

Key : 1  value : geeksforgeeks
Key : 2  value : practice
Key : 3  value : quiz
Key : 4  value : contribute
Key : 5  value : code

创建SortedMap对象

由于SortedMap是一个接口，因此无法创建SortedMap类型的对象。我们始终需要一个扩展此列表的类以创建对象。此外，在Java 1.5引入泛型之后，可以限制可以存储在SortedMap中的对象类型。此安全类型的映射可以定义为：

// Obj1，Obj2是要存储在SortedMap中的对象的类型

SortedMap<Obj1，Obj2> set = new TreeMap<Obj1，Obj2>（）;

执行SortedMap上的各种操作

由于SortedMap是一个接口，因此它只能与实现此接口的类一起使用。实现SortedMap界面的类是 TreeMap 。现在，让我们看看如何在TreeMap上执行一些经常使用的操作。

1. 添加元素： 为了向SortedMap中添加元素，我们可以使用 put() 方法。但是，TreeMap中不保留插入顺序。在内部，针对每个元素，按键进行比较和按升序排序。

// Java程序将元素添加到SortedMap中
import java.io.*;
import java.util.*;
class GFG {
 
    // 主方法
    public static void main(String args[])
    {
        // 默认初始化
        // SortedMap
        SortedMap tm1 = new TreeMap();
 
        // 使用泛型初始化
        SortedMap<Integer, String> tm2
            = new TreeMap<Integer, String>();
 
        // 插入元素
        tm1.put(3, "Geeks");
        tm1.put(2, "For");
        tm1.put(1, "Geeks");
 
        tm2.put(new Integer(3), "Geeks");
        tm2.put(new Integer(2), "For");
        tm2.put(new Integer(1), "Geeks");
 
        System.out.println(tm1);
        System.out.println(tm2);
    }
}

输出

{1=Geeks，2=For，3=Geeks}
{1=Geeks，2=For，3=Geeks}

2. 更改元素： 在添加元素后，如果希望更改元素，可以再次使用put()方法添加元素。由于SortedMap中的元素是使用键进行索引的，因此可以通过为需要更改的键插入更新后的值来更改键的值。

// Java程序，用于更改
// SortedMap中的元素
import java.io.*;
import java.util.*;
class GFG {
   
      // 主方法
    public static void main(String args[])
    {
        // 使用泛型初始化SortedMap
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
 
        // 插入元素
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
 
        System.out.println(tm);
 
        tm.put(2, "For");
 
        System.out.println(tm);
    }
}

输出结果

{1=Geeks, 2=Geeks, 3=Geeks}
{1=Geeks, 2=For, 3=Geeks}

3. 删除元素： 为了从SortedMap中移除元素，我们可以使用remove()方法。如果这个方法存在于map中，则按键值删除键的映射。

// Java程序，用于从SortedMap中删除元素
import java.io.*;
import java.util.*;
 
class GFG {
   
      // 主方法
    public static void main(String args[])
    {
        // 初始化SortedMap，使用泛型
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
 
        // 插入元素
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
        tm.put(4, "For");
 
        System.out.println(tm);
 
        tm.remove(4);
 
        System.out.println(tm);
    }
}

输出结果

{1=Geeks, 2=Geeks, 3=Geeks, 4=For}
{1=Geeks, 2=Geeks, 3=Geeks}

4. 遍历SortedMap： 遍历Map有多种方法，其中最著名的方法是使用增强for循环并获取键。通过调用getValue()方法获取键的值。

// Java程序，用于遍历SortedMap
import java.util.*;
 
class GFG {
   
      // 主方法
    public static void main(String args[])
    {
        // 初始化SortedMap，使用泛型
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
 
        // 插入元素
        tm.put(3, "Geeks");
        tm.put(2, "For");
        tm.put(1, "Geeks");
 
        for (Map.Entry mapElement : tm.entrySet()) {
            int key = (int)mapElement.getKey();
 
            // 查找值
            String value = (String)mapElement.getValue();
 
            System.out.println(key + " : " + value);
        }
    }
}

输出结果

1 : Geeks
2 : For
3 : Geeks

SortedMap接口实现的类是TreeMap。

在集合框架中实现的TreeMap类是SortedMap接口的实现，SortedMap接口扩展Map接口。它的行为类似于一个简单的Map，但它以排序格式存储键。TreeMap使用树数据结构进行存储，对象按升序排序存储。但我们也可以通过传递比较器以按降序存储。现在让我们看看如何使用该类创建SortedMap对象。

// Java程序演示使用TreeMap类创建SortedMap对象
 
import java.util.*;
 
class GFG {
 
    public static void main(String[] args)
    {
        SortedMap<String, String> tm
            = new TreeMap<String, String>(new Comparator<String>() {
                  public int compare(String a, String b)
                  {
                      return b.compareTo(a);
                  }
              });
 
        //使用put()方法将元素添加到TreeMap中
        tm.put("India", "1");
        tm.put("Australia", "2");
        tm.put("South Africa", "3");
 
        //展示TreeMap
        System.out.println(tm);
 
        //使用remove()方法从TreeMap中移除元素
        tm.remove("Australia");
        System.out.println("移除Australia后的Map:" + tm);
    }
}

输出

{South Africa=3, India=1, Australia=2}
移除Australia后的Map:{South Africa=3, India=1}

SortedMap接口的方法

方法	描述
comparator()	返回用于对Map中键进行排序的比较器，如果此Map使用其键的自然排序，则返回null。
entrySet()	返回此Map中包含的映射的Set视图。
firstKey()	返回当前Map中的第一个（最低）键。
headMap(K toKey)	返回键严格小于toKey的Map部分的视图。
keySet()	返回此Map中键的Set视图。
lastKey()	返回当前Map中的最后一个（最高）键。
subMap(K fromKey, K toKey)	返回键范围为fromKey（含）到toKey（不含）的Map部分的视图。
tailMap(K fromKey)	返回键大于或等于fromKey的Map部分的视图。
values()	返回此Map中值的Collection视图。

Map接口继承的方法

方法	描述
clear()	该方法用于清空并删除指定Map集合中的所有元素或映射。（即清空映射关系）
containsKey（Object）	该方法用于检查是否将特定键映射到Map中。它将键元素作为参数，并返回True（True代表是，False代表否）如果该元素在映射中，则该元素被映射。
containsValue（Object）	该方法用于检查是否单个或多个键将某个特定值映射到Map中。它将值作为参数，并返回True（True代表是，False代表否）如果该值由该映射中的任何键映射。
entrySet（）	该方法用于从映射中创建一个包含相同元素的集合。它基本上返回地图的集合视图或者说我们可以创建一个新集合并将地图元素存储在其中。
equals（Object）	该方法用于检查两个地图之间的相等性。它验证传递作为参数的一个地图的元素是否等于此地图的元素。
get（Object）	该方法用于检索或获取由参数中提到的特定键映射的值。如果映射不包含该键的映射，则返回NULL。
hashCode（）	该方法用于为包含键和值的给定映射生成哈希码。
isEmpty（）	该方法用于检查地图是否具有任何键和值对的条目。如果不存在映射，则返回true。
keySet（）	该方法用于返回此地图中包含的键的Set视图。该集合由地图支持，因此地图对集合的更改会反映在集合中，反之亦然。
put（Object，Object）	该方法用于将指定的值与指定的键关联到此地图中。
putAll（Map）	该方法用于将指定映射中的所有映射复制到此映射中。
remove（Object）	该方法用于从映射中删除键的映射（如果存在）。
size（）	该方法用于返回映射中可用的键/值对的数量。
values（）	该方法用于创建Map中值的集合。它基本上返回HashMap中值的Collection视图。