Iterar lista en orden inverso en Java

Recopilación

Ejemplo

Input: ["geeks", "for", "Geeks"]
Output: ["Geeks", "for", "geeks"]
 
Input: [ 1, 2, 3, 4, 5]
output: [5, 4, 3, 2, 1]

Podemos iterar la lista en orden inverso de dos maneras:

1. Usando List.listIterator() y usando el método de bucle for.
2.  Usando el rango IntStream (int startInclusive, int endExclusive).

Enfoque 1: uso de List.listIterator() y uso del método de bucle .

Sintaxis:

public ListIterator listIterator()

Valor devuelto: este método devuelve un iterador de lista sobre los elementos de esta lista (en la secuencia adecuada).

• Esto permite el acceso bidireccional.
• El método List.listIterator() se utiliza para obtener un ListIterator sobre los elementos de una lista a partir de la posición especificada en la lista. Si necesitamos comenzar desde el último elemento, el índice inicial sería igual al tamaño de la lista.

Sintaxis:

ListIterator<Integer> listIterator( Index )

Index = Index from where list element will reverse till index = 0.

// Java program to iterate List in Reverse Order
  
import java.util.*;
  
class GFG {
  
    public static void main(String[] args)
    {
  
        // For ArrayList
        List<String> list = new ArrayList<String>();
  
        // Add elements to list
        list.add("GEEKS");
        list.add("for");
        list.add("geeks");
  
        // Generate an iterator to iterate List in reverse
        // order
        ListIterator<String> gfg_itr
            = list.listIterator(list.size());
  
        // hasPrevious() returns true if the list has
        // previous element
        while (gfg_itr.hasPrevious()) 
        {
            // Iterate in reverse
            System.out.println(gfg_itr.previous());
        }
  
        // print list in Reverse using for loop
        for (int i = list.size() - 1; i >= 0; i--)
        {
            // access elements by their index (position)
            System.out.println(list.get(i));
        }
    }
}

geeks
for
GEEKS
geeks
for
GEEKS

Enfoque 2: Uso

• Esto devuelve un IntStream ordenado secuencialmente desde startInclusive (inclusivo) hasta endExclusive (exclusivo) en un paso incremental de 1. Maneja correctamente el desbordamiento.

Sintaxis: 

static IntStream range(int startInclusive,   int endExclusive)

Parámetros:

• IntStream: una secuencia de elementos primitivos de valor int.
• startInclusive : el valor inicial inclusivo.
• endExclusive : el límite superior exclusivo.

// Java Program to iterate List in reverse order
  
import java.util.*;
import java.util.stream.IntStream;
  
class GFG {
  
    public static void main(String[] args)
    {
  
        // For ArrayList
        List<Integer> list_li = new ArrayList<Integer>();
  
        // Add elements to list
        list_li.add(1);
        list_li.add(2);
        list_li.add(3);
        list_li.add(4);
        list_li.add(5);
  
        // Creating an IntStream
        IntStream stream = IntStream.range(0, list_li.size());
  
        // Displaying the elements in range
        // including the lower bound but
        // excluding the upper bound
        stream.map(i -> list_li.size() - i - 1).map(list_li::get)
            .forEach(System.out::println);
    }
}

5
4
3
2
1

Nota: el rango IntStream (int startInclusive, int endExclusive) básicamente funciona como un bucle for. Una secuencia equivalente de valores crecientes se puede producir secuencialmente como:

for (int i = startInclusive; i < endExclusive ; i++) 
{
 ...
 ...
 ...
}