SortedMap é uma interface na estrutura de coleção . Essa interface estende a interface Map e fornece uma ordem total de seus elementos (os elementos podem ser percorridos na ordem de classificação das chaves). A classe que implementa essa interface é TreeMap .
 

A principal característica de um SortedMap é que ele ordena as chaves por sua ordem natural ou por um comparador especificado. Portanto, considere usar um TreeMap quando quiser um mapa que satisfaça os seguintes critérios: 

• chave nula ou valor nulo não são permitidos.
• As chaves são classificadas por ordem natural ou por um comparador especificado.

Parâmetros de tipo:

• K - o tipo de chaves mantidas por este mapa
• V - o tipo de valores mapeados

A interface pai de SortedMap é Map <K, V>.  

As subInterfaces de SortedMap são ConcurrentNavigableMap <K, V>, NavigableMap <K, V>.

SortedMap é implementado por ConcurrentSkipListMap, TreeMap.

Declaração:

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();
}

 Exemplo:

// Java code to demonstrate SortedMap Interface
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();
  
        // Using iterator in SortedMap
        Iterator i = s.iterator();
  
        // Traversing map. Note that the traversal
        // produced sorted (by keys) output .
        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);
        }
    }
}

Saída: 
 

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

Criação de objetos SortedMap

Como SortedMap é uma interface , não podem ser criados objetos do tipo SortedMap. Sempre precisamos de uma classe que estenda essa lista para criar um objeto. E também, após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no SortedMap. Este mapa de tipo seguro pode ser definido como:

// Obj1, Obj2 são o tipo de objeto a ser armazenado no SortedMap

SortedMap <Obj1, Obj2> set = new TreeMap <Obj1, Obj2>();

Execução de várias operações no SortedMap

Como SortedMap é uma interface, ele pode ser usado apenas com uma classe que implementa essa interface. TreeMap é a classe que implementa a interface SortedMap. Agora, vamos ver como realizar algumas operações usadas com frequência no TreeMap.

1. Adicionando Elementos: Para adicionar um elemento ao SortedMap, podemos usar o método put() . No entanto, a ordem de inserção não é retida no TreeMap. Internamente, para cada elemento, as chaves são comparadas e classificadas em ordem crescente.

// Java program add the elements in the SortedMap
import java.io.*;
import java.util.*;
class GFG {
  
    // Main Method
    public static void main(String args[])
    {
        // Default Initialization of a
        // SortedMap
        SortedMap tm1 = new TreeMap();
  
        // Initialization of a SortedMap
        // using Generics
        SortedMap<Integer, String> tm2
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        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);
    }
}

Saída:

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

2. Mudando os Elementos: Depois de adicionar os elementos, se desejarmos mudar o elemento, isso pode ser feito adicionando novamente o elemento com o método put() . Como os elementos no SortedMap são indexados usando as chaves, o valor da chave pode ser alterado simplesmente inserindo o valor atualizado para a chave que desejamos alterar.

// Java program to change
// the elements in SortedMap
import java.io.*;
import java.util.*;
class GFG {
    
      // Main Method
    public static void main(String args[])
    {
        // Initialization of a SortedMap
        // using Generics
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
  
        System.out.println(tm);
  
        tm.put(2, "For");
  
        System.out.println(tm);
    }
}

Saída:

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

3. Removendo Elemento: Para remover um elemento do SortedMap, podemos usar o método remove() . Este método pega o valor da chave e remove o mapeamento para a chave deste SortedMap se estiver presente no mapa.

// Java program to remove the 
// elements from SortedMap
import java.io.*;
import java.util.*;
  
class GFG {
    
      // Main Method
    public static void main(String args[])
    {
        // Initialization of a SortedMap
        // using Generics
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        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);
    }
}

Saída:

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

4. Iterando por meio do SortedMap: Existem várias maneiras de iterar por meio do Mapa. A maneira mais famosa é usar um loop for aprimorado e obter as chaves. O valor da chave é encontrado usando o método getValue().

// Java program to iterate through SortedMap
import java.util.*;
  
class GFG {
    
      // Main Method
    public static void main(String args[])
    {
        // Initialization of a SortedMap
        // using Generics
        SortedMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "For");
        tm.put(1, "Geeks");
  
        for (Map.Entry mapElement : tm.entrySet()) {
            int key = (int)mapElement.getKey();
  
            // Finding the value
            String value = (String)mapElement.getValue();
  
            System.out.println(key + " : " + value);
        }
    }
}

Saída:

1 : Geeks
2 : For
3 : Geeks

A classe que implementa a interface SortedMap é TreeMap.

A classe TreeMap que é implementada na estrutura de coleções é uma implementação da Interface SortedMap e SortedMap estende a Interface do Mapa. Ele se comporta como um mapa simples, com a exceção de que armazena as chaves em um formato classificado. TreeMap usa uma estrutura de dados em árvore para armazenamento. Os objetos são armazenados em ordem crescente. Mas também podemos armazenar em ordem decrescente, passando um comparador. Vamos ver como criar um objeto SortedMap usando esta classe.

// Java program to demonstrate the
// creation of SortedMap object using
// the TreeMap class
  
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);
                  }
              });
  
        // Adding elements into the TreeMap
        // using put()
        tm.put("India", "1");
        tm.put("Australia", "2");
        tm.put("South Africa", "3");
  
        // Displaying the TreeMap
        System.out.println(tm);
  
        // Removing items from TreeMap
        // using remove()
        tm.remove("Australia");
        System.out.println("Map after removing "
                           + "Australia:" + tm);
    }
}

Saída:

{South Africa=3, India=1, Australia=2}
Map after removing Australia:{South Africa=3, India=1}

Métodos de interface SortedMap

Métodos herdados da interface java.util.Map

Este artigo é uma contribuição de Pratik Agarwal . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando contribute.geeksforgeeks.org ou enviar o seu artigo para contribute@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.
Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima.