Interfaz SortedMap en Java con ejemplos

SortedMap es una interfaz en el marco de la colección . Esta interfaz amplía la interfaz del Mapa y proporciona un ordenamiento total de sus elementos (los elementos se pueden recorrer en orden ordenado de claves). La clase que implementa esta interfaz es TreeMap .
 

La característica principal de un SortedMap es que ordena las claves por su orden natural o por un comparador específico. Así que considere usar un TreeMap cuando desee un mapa que satisfaga los siguientes criterios: 

• No se permite la clave nula o el valor nulo.
• Las claves se clasifican por orden natural o por un comparador específico.

Parámetros de tipo:

• K – el tipo de claves mantenidas por este mapa
• V – el tipo de valores mapeados

La interfaz principal de SortedMap es Map<K, V>.  

Las subinterfaces de SortedMap son ConcurrentNavigableMap<K, V>, NavigableMap<K, V>.

SortedMap se implementa mediante ConcurrentSkipListMap, TreeMap.

Declaración:

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

 Ejemplo:

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

Producción: 
 

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

Creación de objetos SortedMap

Dado que SortedMap es una interfaz , no se pueden crear objetos del tipo SortedMap. Siempre necesitamos una clase que amplíe esta lista para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en SortedMap. Este mapa de tipo seguro se puede definir como:

// Obj1, Obj2 son el tipo de objeto que se almacenará en SortedMap

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

Realización de varias operaciones en SortedMap

Dado que SortedMap es una interfaz, solo se puede usar con una clase que implemente esta interfaz. TreeMap es la clase que implementa la interfaz SortedMap. Ahora, veamos cómo realizar algunas operaciones de uso frecuente en el TreeMap.

1. Agregar elementos: para agregar un elemento a SortedMap, podemos usar el método put() . Sin embargo, el orden de inserción no se conserva en el TreeMap. Internamente, para cada elemento, las claves se comparan y clasifican en orden ascendente.

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

Producción:

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

2. Cambio de elementos: después de agregar los elementos, si deseamos cambiar el elemento, se puede hacer agregando nuevamente el elemento con el método put() . Dado que los elementos en SortedMap se indexan usando las claves, el valor de la clave se puede cambiar simplemente insertando el valor actualizado de la clave para la que deseamos cambiar.

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

Producción:

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

3. Eliminación de elementos: para eliminar un elemento de SortedMap, podemos usar el método remove() . Este método toma el valor de la clave y elimina la asignación de la clave de este SortedMap si está presente en el 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);
    }
}

Producción:

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

4. Iterando a través de SortedMap: Hay varias formas de iterar a través del Mapa. La forma más famosa es usar un bucle for mejorado y obtener las claves. El valor de la clave se encuentra utilizando el 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);
        }
    }
}

Producción:

1 : Geeks
2 : For
3 : Geeks

La clase que implementa la interfaz SortedMap es TreeMap.

La clase TreeMap que se implementa en el marco de las colecciones es una implementación de la interfaz SortedMap y SortedMap amplía la interfaz de mapa. Se comporta como un mapa simple con la excepción de que almacena claves en un formato ordenado. TreeMap utiliza una estructura de datos de árbol para el almacenamiento. Los objetos se almacenan en orden ascendente ordenado. Pero también podemos almacenar en orden descendente pasando un comparador. Veamos cómo crear un objeto SortedMap usando esta clase.

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

Producción:

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

Métodos de la interfaz SortedMap

Métodos heredados de la interfaz java.util.Map

Este artículo es una contribución de Pratik Agarwal . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.