Iterar TreeMap en orden inverso en Java

TreeMap en Java se utiliza para implementar la interfaz Map y NavigableMap junto con la clase AbstractMap . El TreeMap se ordena según el orden natural de sus claves.

Hay tres formas sencillas de iterar TreeMap en orden inverso en Java:

1. Usando el método reverseOrder()
2. Usando el método descendingKeySet()
3. Usando el método descendingMap()

Método 1:

El método reverseOrder() de la clase Collections devuelve un Comparator que impone el orden inverso al natural de los objetos. Use esto en el constructor de TreeMap para crear un objeto que almacene el mapeo en el orden inverso de las claves.

// Usar el método reverseOrder() en el constructor
TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>(Collections.reverseOrder());

A continuación se muestra la implementación:

// Java Program to iterate TreeMap in Reverse Order in Java
 
import java.util.*;
 
public class GFG {
    public static void main(String[] args)
    {
 
        // Use reverseOrder() method in the constructor
        TreeMap<Integer, String> treeMap
            = new TreeMap<>(Collections.reverseOrder());
 
        // Add elements to treeMap
        treeMap.put(1, "Hello");
        treeMap.put(2, "geeks");
        treeMap.put(3, "on");
        treeMap.put(4, "geeksforgeeks");
 
        // Print the TreeMap in reverse order of the keys
        System.out.println("TreeMap in reverse order: "
                           + treeMap);
    }
}

TreeMap in reverse order: {4=geeksforgeeks, 3=on, 2=geeks, 1=Hello}

Complejidad de tiempo: O(N)

Método 2:

El método descendingKeySet() devuelve una vista Set de orden inverso de las claves. Así que itere sobre la vista establecida que devuelve las claves de TreeMap en orden descendente y obtenga el valor con la ayuda del método get().

Nota: El conjunto de claves devuelto por el método descendingKeySet() es una vista y está respaldado por el objeto TreeMap original. Cualquier cambio realizado en esta vista se reflejará en el objeto TreeMap original y viceversa.

A continuación se muestra la implementación:

// Java Program to iterate TreeMap in Reverse Order in Java
 
import java.util.*;
 
public class GFG {
    public static void main(String[] args)
    {
 
        // New TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<>();
 
        // Add elements to treeMap
        treeMap.put(1, "Hello");
        treeMap.put(2, "geeks");
        treeMap.put(3, "on");
        treeMap.put(4, "geeksforgeeks");
 
        // Print the TreeMap
        System.out.println("TreeMap before reverse: "
                           + treeMap);
 
        // view set of the keys in reverseOrder
        Set<Integer> keySet = treeMap.descendingKeySet();
 
        // After reverse
        System.out.println("TreeMap after reverse:");
 
        // Iterate view set of the keys
        // and get value of the key
        for (Integer key : keySet) {
            // Print key:value of the TreeMap
            System.out.println(key + " = "
                               + treeMap.get(key));
        }
    }
}

TreeMap before reverse: {1=Hello, 2=geeks, 3=on, 4=geeksforgeeks}
TreeMap after reverse:
4 = geeksforgeeks
3 = on
2 = geeks
1 = Hello

Complejidad de tiempo: O(N)

Método 3:

El método descendingMap() de la clase TreeMap devuelve un mapa que contiene una vista inversa de las asignaciones. Iterar sobre el mapa usando el iterador del conjunto de entrada.

Nota: El mapa descendente devuelto por el método descendingMap() es una vista, por lo que cualquier cambio realizado se reflejará en el TreeMap original y viceversa.

A continuación se muestra la implementación:

// Java Program to iterate TreeMap in Reverse Order in Java
 
import java.util.*;
 
public class GFG {
    public static void main(String[] args)
    {
 
        // New TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<>();
 
        // Add elements to treeMap
        treeMap.put(1, "Hello");
        treeMap.put(2, "geeks");
        treeMap.put(3, "on");
        treeMap.put(4, "geeksforgeeks");
 
        // Before reverse
        System.out.println("TreeMap before reverse:"
                           + treeMap);
 
        // view map containing reverse view of mapping
        Map<Integer, String> reverseMap
            = treeMap.descendingMap();
 
        // After reverse
        System.out.println("TreeMap after reverse:"
                           + reverseMap);
    }
}

TreeMap before reverse:{1=Hello, 2=geeks, 3=on, 4=geeksforgeeks}
TreeMap after reverse:{4=geeksforgeeks, 3=on, 2=geeks, 1=Hello}

Complejidad de tiempo: O(N)