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.
Java
// 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().
Java
// 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.
Java
// 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.
Java
// 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
Publicación traducida automáticamente
Artículo escrito por kushwahp1234 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA