Programa Java para obtener el submapa ordenado de TreeMap

TreeMap en Java son contenedores que almacenan elementos en una forma asignada que es un par clave-valor y valor asignado. Cada elemento tiene una clave – valor y un valor mapeado respectivo. Todos los valores clave son únicos y es necesario que dos valores asignados no puedan tener el mismo valor clave. Se basa en la implementación Red-Black Tree en la que no importa en qué orden se inserten los valores en TreeMap, permanecen ordenados según su clave, a diferencia de HashMap.

Sintaxis de TreeMap:

TreeMap<Integer, String> tree_map= new TreeMap<Integer, String>();

Sintaxis de SubMapa:

Caso 1: el método incluirá la clave inicial pero no la clave final

tree_map.submap(starting_key, ending_key);

Caso 2: para incluir ambas claves, pase verdadero con claves

tree_map.submap(starting_key, true, ending_key, true);

Caso 3: Para excluir cualquier clave, pase falso con clave 

tree_map.submap(starting_key, false, ending_key, true);

 Métodos:

1. método de fuerza bruta
2. Uso de una función predefinida
3. Usando el comparador definido
4. Usando el comparador definido por el usuario

Método 1: Impresión del submapa ordenado predeterminado  

// Java Program to  Get Sorted Sub-Map from TreeMap
 
// Importing all classes of
// java.util package
import java.util.*;
 
public class GFG {
   
    // Main driver code
    public static void main(String[] args)
    {
        // Create a TreeMap
        TreeMap<Integer, String> my_map
            = new TreeMap<Integer, String>();
 
        // Adding Element to TreeMap
        my_map.put(5, "DoubleAlpha");
        my_map.put(1, "Alpha");
        my_map.put(3, "Beta");
        my_map.put(2, "Gamma");
        my_map.put(4, "Theta");
 
        // Printing default sorted elements in given range
        // using subMap function
        System.out.println(
            "Elements:  "
            + my_map.subMap(1, true, 5, true));
    }
}

Elements:  {1=Alpha, 2=Gamma, 3=Beta, 4=Theta, 5=DoubleAlpha}

Método 2: Mapa ordenado invertido usando funciones predefinidas

Ejemplo: 

// Java Program to  Get Sorted Sub-Map from TreeMap
// using predefined functions
 
// Importing all classes of
// java.util package
import java.util.*;
 
public class GFG {
 
    // Main driver code
    public static void main(String[] args)
    {
        // Create a TreeMap
        TreeMap<Integer, String> my_map
            = new TreeMap<Integer, String>();
 
        // Adding elements to TreeMap
        my_map.put(5, "DoubleAlpha");
        my_map.put(1, "Alpha");
        my_map.put(3, "Beta");
        my_map.put(2, "Gamma");
        my_map.put(4, "Theta");
 
        // Reversing elements of map in
        // descending order
        Map<Integer, String> reversed_map
            = my_map.descendingMap();
 
        // Printing default reverse sorted elements
        // using subMap() function
        System.out.println("Elements:  " + reversed_map);
    }
}

Elements:  {5=DoubleAlpha, 4=Theta, 3=Beta, 2=Gamma, 1=Alpha}

Método 3: Impresión del submapa ordenado utilizando el comparador definido por el usuario

La idea detrás del comparador definido por el usuario es que si el usuario desea ordenar el mapa según sus preferencias. Comparar la función del comparador se utiliza para implementar nuestra lógica de clasificación. 

Ejemplo: 

// Java Program to  Get Sorted Sub-Map from TreeMap
// using user-defined comparator
 
// Importing all classes of
// java.util package
import java.util.*;
 
// Class
public class GFG {
 
    // Main driver Code
    public static void main(String a[])
    {
 
        // Sorting TreeMap by key
        TreeMap<String, String> my_map
            = new TreeMap<String, String>(new UserComp());
 
        // Add key-value pair to TreeMap
        my_map.put("DoubleAlpha", "RedDotGeek");
        my_map.put("Alpha", "GeekAmongGeek");
        my_map.put("Beta", "MasterGeek");
        my_map.put("Gamma", "Geek");
        my_map.put("Theta", "OnwayGeek");
 
        // Display above added elements of TreeMap
        System.out.println(
            "Elements:  "
            + my_map.subMap("A", true, "Z", true));
    }
}
 
// Pre-defined comparator
class UserComp implements Comparator<String> {
 
    public int compare(String a, String b)
    {
        return a.compareTo(b);
    }
}

Elements:  {Alpha=GeekAmongGeek, Beta=MasterGeek, DoubleAlpha=RedDotGeek, Gamma=Geek, Theta=OnwayGeek}

Método 4: Mapa ordenado invertido utilizando el comparador definido por el usuario 

// Java Program to  Get Sorted Sub-Map from TreeMap
// using pre-defined comparator
 
// Importing all classes of
// java.util package
import java.util.*;
 
public class GFG {
 
    // Main driver method
    public static void main(String a[])
    {
        // Sorting treeMap by key
        TreeMap<Integer, String> my_map
            = new TreeMap<Integer, String>(new UserComp());
 
        // Adding key-value pair to TreeMap
        my_map.put(1, "DoubleAlpha");
        my_map.put(8, "Alpha");
        my_map.put(5, "Beta");
        my_map.put(3, "Gamma");
        my_map.put(4, "Theta");
 
        // Display elements added of TreeMap
        System.out.println("Elements : " + my_map);
    }
}
 
// Defined comparator
class UserComp implements Comparator<Integer> {
 
    public int compare(Integer a, Integer b)
    {
        if (b > a)
            return 1;
        return -1;
    }
}

Elements : {8=Alpha, 5=Beta, 4=Theta, 3=Gamma, 1=DoubleAlpha}