Suponiendo que haya revisado arraylist en Java y conozca arraylist. Esta publicación contiene diferentes ejemplos para revertir una lista de arreglos que se dan a continuación:
1. Escribiendo nuestra propia función ( usando espacio adicional ): el método reverseArrayList() en la clase RevArrayList contiene lógica para revertir una lista de arreglos con objetos enteros. Este método toma una lista de arreglos como parámetro, la atraviesa en orden inverso y agrega todos los elementos a la lista de arreglos recién creada. Finalmente, se devuelve la lista de arrays invertida.
Java
// Java program for reversing an arraylist
import java.io.*;
import java.util.*;
class RevArrayList {
// Takes an arraylist as a parameter and returns
// a reversed arraylist
public ArrayList<Integer> reverseArrayList(ArrayList<Integer> alist)
{
// Arraylist for storing reversed elements
ArrayList<Integer> revArrayList = new ArrayList<Integer>();
for (int i = alist.size() - 1; i >= 0; i--) {
// Append the elements in reverse order
revArrayList.add(alist.get(i));
}
// Return the reversed arraylist
return revArrayList;
}
// Iterate through all the elements and print
public void printElements(ArrayList<Integer> alist)
{
for (int i = 0; i < alist.size(); i++) {
System.out.print(alist.get(i) + " ");
}
}
}
public class GFG {
public static void main(String[] args)
{
RevArrayList obj = new RevArrayList();
// Declaring arraylist without any initial size
ArrayList<Integer> arrayli = new ArrayList<Integer>();
// Appending elements at the end of the list
arrayli.add(new Integer(1));
arrayli.add(new Integer(2));
arrayli.add(new Integer(3));
arrayli.add(new Integer(4));
System.out.print("Elements before reversing:");
obj.printElements(arrayli);
arrayli = obj.reverseArrayList(arrayli);
System.out.print("\nElements after reversing:");
obj.printElements(arrayli);
}
}
Elements before reversing:1 2 3 4 Elements after reversing:4 3 2 1
1. Al escribir nuestra propia función ( sin usar espacio adicional ): en el ejemplo anterior, se usa adicionalmente una lista de arreglos para almacenar todos los elementos invertidos, lo que ocupa más espacio. Para evitar eso, se puede usar la misma lista de arreglos para invertir.
Lógica:
1. Ejecute el ciclo n/2 veces donde ‘n’ es el número de elementos en la lista de arreglos.
2. En el primer pase, intercambie el primer y el n-ésimo elemento
3. En el segundo pase, intercambie el segundo y el (n-1)-ésimo elemento y así sucesivamente hasta llegar a la mitad de la lista de arreglos.
4. Devuelva la lista de arreglos después de la terminación del ciclo.
Java
// Java program for reversing an arraylist
import java.io.*;
import java.util.*;
class RevArrayList {
// Takes an arraylist as a parameter and returns
// a reversed arraylist
public ArrayList<Integer> reverseArrayList(ArrayList<Integer> alist)
{
// Arraylist for storing reversed elements
// this.revArrayList = alist;
for (int i = 0; i < alist.size() / 2; i++) {
Integer temp = alist.get(i);
alist.set(i, alist.get(alist.size() - i - 1));
alist.set(alist.size() - i - 1, temp);
}
// Return the reversed arraylist
return alist;
}
// Iterate through all the elements and print
public void printElements(ArrayList<Integer> alist)
{
for (int i = 0; i < alist.size(); i++) {
System.out.print(alist.get(i) + " ");
}
}
}
public class GFG1 {
public static void main(String[] args)
{
RevArrayList obj = new RevArrayList();
// Declaring arraylist without any initial size
ArrayList<Integer> arrayli = new ArrayList<Integer>();
// Appending elements at the end of the list
arrayli.add(new Integer(12));
arrayli.add(new Integer(13));
arrayli.add(new Integer(123));
arrayli.add(new Integer(54));
arrayli.add(new Integer(1));
System.out.print("Elements before reversing: ");
obj.printElements(arrayli);
arrayli = obj.reverseArrayList(arrayli);
System.out.print("\nElements after reversing: ");
obj.printElements(arrayli);
}
}
Elements before reversing: 12 13 123 54 1 Elements after reversing: 1 54 123 13 12
2. Mediante el uso de la clase Collections: Collections es una clase en el paquete java.util que contiene varios métodos estáticos para buscar, clasificar, invertir, encontrar máximos, mínimos, etc. Podemos hacer uso del método Collections.reverse() incorporado para invertir una lista de arrays. Toma una lista como parámetro de entrada y devuelve la lista invertida.
Java
// Java program for reversing an arraylist
import java.io.*;
import java.util.*;
public class GFG2 {
public static void main(String[] args)
{
// Declaring arraylist without any initial size
ArrayList<Integer> arrayli = new ArrayList<Integer>();
// Appending elements at the end of the list
arrayli.add(new Integer(9));
arrayli.add(new Integer(145));
arrayli.add(new Integer(878));
arrayli.add(new Integer(343));
arrayli.add(new Integer(5));
System.out.print("Elements before reversing: ");
printElements(arrayli);
// Collections.reverse method takes a list as a
// parameter and reverses the passed parameter
//(no new array list is required)
Collections.reverse(arrayli);
System.out.print("\nElements after reversing: ");
printElements(arrayli);
}
// Iterate through all the elements and print
public static void printElements(ArrayList<Integer> alist)
{
for (int i = 0; i < alist.size(); i++) {
System.out.print(alist.get(i) + " ");
}
}
}
Elements before reversing: 9 145 878 343 5 Elements after reversing: 5 343 878 145 9
3. Invertir una lista de array de objetos definidos por el usuario: se crea una clase de empleado para crear objetos definidos por el usuario con ID de empleado, nombre de empleado, nombre de departamento como variables de clase que se inicializan en el constructor. Se crea una lista de arrays que solo toma objetos de empleado (definidos por el usuario). Estos objetos se agregan a la lista de arreglos usando el método add(). La lista de arreglos se invierte usando el método inverso() incorporado de la clase Collections.
El método estático printElements() se usa solo para evitar escribir una clase más en el programa.
Java
// Java program for reversing an arraylist
import java.io.*;
import java.util.*;
class Employee {
int empID;
String empName;
String deptName;
// Constructor for initializing the class variables
public Employee(int empID, String empName, String deptName)
{
this.empID = empID;
this.empName = empName;
this.deptName = deptName;
}
}
public class GFG3 {
public static void main(String[] args)
{
// Declaring arraylist without any initial size
ArrayList<Employee> arrayli = new ArrayList<Employee>();
// Creating user defined objects
Employee emp1 = new Employee(123, "Rama", "Facilities");
Employee emp2 = new Employee(124, "Lakshman", "Transport");
Employee emp3 = new Employee(125, "Ravan", "Packing");
// Appending all the objects for arraylist
arrayli.add(emp1);
arrayli.add(emp2);
arrayli.add(emp3);
System.out.print("Elements before reversing: ");
printElements(arrayli);
// Collections.reverse method takes a list as a
// parameter and reverse the list
Collections.reverse(arrayli);
System.out.print("\nElements after reversing: ");
printElements(arrayli);
}
// Iterate through all the elements and print
public static void printElements(ArrayList<Employee> alist)
{
for (int i = 0; i < alist.size(); i++) {
System.out.print("\n EmpID:" + alist.get(i).empID +
", EmpName:" + alist.get(i).empName + ", Department:" +
alist.get(i).deptName);
}
}
}
Elements before reversing: EmpID:123, EmpName:Rama, Department:Facilities EmpID:124, EmpName:Lakshman, Department:Transport EmpID:125, EmpName:Ravan, Department:Packing Elements after reversing: EmpID:125, EmpName:Ravan, Department:Packing EmpID:124, EmpName:Lakshman, Department:Transport EmpID:123, EmpName:Rama, Department:Facilities