Programa Java para atravesar ArrayList en dirección inversa

ArrayList es parte del marco de la colección y está presente en el paquete java.util . Nos proporciona arrays dinámicas en Java al igual que Vector en C++. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. La tarea es insertar un elemento en ArrayList y luego invertirlo o decir invertir la dirección.

Ejemplo :

Input :1, 2, 3, 4, 5, 6 
Output :  6, 5, 4, 3, 2, 1 

Input :  10, 22, 34, 3, 2, 6
Output :  6, 2, 3, 34, 22, 10 

Input :  11, 22, 34, 42, 51 , 63
Output :  63, 51, 42, 34, 22, 11

Hay varios métodos por los cuales podemos iterar e imprimir la lista en dirección inversa que se enumeran a continuación.

Método 1: (usando ListIterator)

1. Declarar una ArrayList

// size of n
ArrayList<Integer> List  = new ArrayList<Integer>(n);

2. Al usar la función de agregar, insertamos el elemento en ArrayList.     

3. Después de llegar al último elemento de ArrayList, recorra usando el iterador. El método hasPrevious() devuelve verdadero si un elemento está presente en la parte posterior del elemento actual, recorre hasta que hasPrevious() devuelva falso.

4. Mientras atraviesa, imprima el elemento actual de ArrayList.

// Traverse through ArrayList in
// reverse direction using List
// Iterator in Java
 
import java.util.ListIterator;
import java.io.*;
import java.util.ArrayList;
 
class GFG {
    public static void main(String[] args)
    {
        // create an instance of arraylist
        ArrayList<Integer> List = new ArrayList<Integer>();
 
        // add elements
        List.add(10);
        List.add(9);
        List.add(8);
        List.add(7);
        List.add(6);
 
        // create a listiterator on list
        ListIterator<Integer> List_Iterator
            = List.listIterator(List.size());
 
        System.out.println("Reversed : ");
 
        // print ArrayList in reverse direction using
        // listiterator
        while (List_Iterator.hasPrevious()) {
            System.out.println(List_Iterator.previous());
        }
    }
}

Reversed : 
6
7
8
9
10

Complejidad de tiempo: O(n)

Espacio auxiliar : O(n) donde n es el tamaño de la Lista

Método 2: (Usando Stream) 

La API Stream se utiliza para procesar colecciones de objetos. Una secuencia es una secuencia de objetos que admite varios métodos que se pueden canalizar para producir el resultado deseado.

• Obtenga Stream usando List.stream().
• Recopile elementos de esta secuencia en una LinkedList usando Stream.collect() .
• Iterar a través de LinkedList en orden secuencial inverso usando el método LinkedList.descendingIterator().
• Realice la operación de impresión en cada elemento de ArrayList usando forEachRemaining(). Podemos proporcionar la referencia del método System.out::println Iterator a forEachRemaining().

// Traverse through ArrayList in
// reverse direction Using
// stream in Java
 
import java.lang.*;
import java.util.stream.*;
import java.util.*;
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
        // create a list
        List<Integer> Arlist = Arrays.asList(5, 2, 4, 8);
        System.out.println("Reversed : ");
 
        // create a stream
        // collect the elements after these operations
        // create a descending iterator on the stream
        // loop through the descending iterator
        // print the element
        Arlist.stream()
            .collect(
                Collectors.toCollection(LinkedList::new))
            .descendingIterator()
            .forEachRemaining(System.out::println);
    }
}

Reversed : 
8
4
2
5

Complejidad de tiempo: O(n)

Espacio auxiliar : O(n) donde n es el tamaño de la Lista

Método 3: (Usando For Loop) Sabemos que List es una colección ordenada, y podemos acceder al elemento de la lista solo por su índice, así que defina un ArrayList e itere desde el último usando un bucle for hasta el primer elemento e imprima cada uno elemento. 

// Traverse through ArrayList in
// reverse direction using For
// Loop in Java
import java.util.*;
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
 
        // create a list
        List<Integer> Arlist = Arrays.asList(5, 4, 8, 2);
 
        System.out.println("Reversed :");
 
        // Printing in reverse
        for (int i = Arlist.size() - 1; i >= 0; i--) {
            System.out.println(Arlist.get(i));
        }
    }
}

Reversed :
2
8
4
5

Complejidad de tiempo: O(n)

Espacio auxiliar : O(n) donde n es el tamaño de la Lista

Método 4: (usando ReverseListIterator de Apache Common)

Este método proporciona ReverseListIterator que podemos usar para iterar List en orden inverso. A medida que usamos ReverseListIterator, next() devolverá el último elemento de la lista de arreglos. Luego, cuando llamemos al siguiente elemento, el siguiente corchete devolverá el elemento anterior del elemento actual, y next verificará si nuestra ArrayList contiene un elemento. O no.

// Traverse through ArrayList in reverse direction using
// ReverseListIterator in Java
 
import org.apache.commons.collections.iterators.ReverseListIterator;
 
import java.util.Arrays;
import java.util.List;
 
class Main {
    public static void main(String[] args)
    {
 
        // create a list
        List<Integer> list = Arrays.asList(1, 5, 8, 7);
 
        // create a reverse listiterator
        ReverseListIterator it
            = new ReverseListIterator(list);
        System.out.println("Reversed : ");
 
        // print the elements
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

Producción 

Reversed :
7
8
5
1

Complejidad de tiempo: O(n)

Espacio auxiliar : O(n) donde n es el tamaño de la Lista