Orden inverso de todos los elementos de Java Vector

Clase de vector Implementa una array dinámica, lo que significa que puede reducir y expandir su tamaño según sea necesario, probablemente tenga las mismas operaciones que en las arrays. No lo confunda con ArrayList ya que hay una delgada línea entre vector y ArrayList, donde el vector está sincronizado y el orden de inserción sigue siendo el mismo en ambos. Vector está presente en el paquete java.util e implementa la interfaz de lista

Ilustración: invertir el orden de los elementos en un vector

Entrada: [1, 2, 3, 4, 5]

Salida: [5, 4, 3, 2, 1]

Entrada: [“GEEKS”, “PARA”, “geeks”]

Salida: [“geeks”, “PARA”, “GEEKS”]

Métodos: 

1. Uso de for-loop (enfoque ingenuo)
2. Usando el método Collection.reverse()
3. Usando el método listIterator()

Método 1: Usar for loop para imprimir el elemento del vector en orden inverso.

// Java program to print vector element
// in reverse using for loop
 
// Importing Vector, Collection & ListIterator classes
// and generic java input output class
import java.io.*;
import java.util.Vector;
import java.util.Collections;
import java.util.ListIterator;
 
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating vector of integer
        Vector<Integer> v1 = new Vector<Integer>();
 
        // Adding element to vector
        // Custom inputs
        v1.add(1);
        v1.add(2);
        v1.add(3);
        v1.add(4);
        v1.add(5);
 
        // Display message
        System.out.println("Before reverse of vector : ");
 
        // Printing all elements of vector before reversing
        System.out.println(v1);
 
        // Display message
        System.out.println("After reverse of vector : ");
 
        // Iterating from last index of vector to 0
        // index = vector.size()-1 (last index)
        for (int i = v1.size() - 1; i >= 0; i--) {
 
            // Printing elements of vector after reversing
            System.out.println(v1.get(i));
        }
    }
}

Before reverse of vector : 
[1, 2, 3, 4, 5]
After reverse of vector : 
5
4
3
2
1

Complejidad temporal: O(n) de n tiempo, donde n es un número de elementos en el vector.

Método 2: el método Collection.reverse() , como sugiere el nombre, es un método de la clase Collection.

Sintaxis:

Collections.reverse(vector) ;

Parámetros: Objeto vectorial a invertir

Valor de retorno: Devuelve el reverso del elemento vector.

// Java Program to reverse order of elements of vector
 
// Importing generic java input/output classes
import java.io.*;
 
// Importing Vector and Collection class
// from java.util package
import java.util.Vector;
import java.util.Collections;
 
// Main Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Create a Vector object
        Vector<String> v = new Vector<String>();
 
        // Add elements to Vector
        v.add("GFG");
        v.add("EarlierGreen");
        v.add("NowBlack");
 
        // Display vector element before reversing
        System.out.println(
            "Before Reverse Order, Vector Contains : " + v);
 
        // reverse() method to reverse vector element
        // by passing vector object so as to reverse
        Collections.reverse(v);
 
        // Display vector element after reversing
        System.out.println(
            "After Reverse Order, Vector Contains : " + v);
    }
}

Before Reverse Order, Vector Contains : [GFG, EarlierGreen, NowBlack]
After Reverse Order, Vector Contains : [NowBlack, EarlierGreen, GFG]

Método 3: Usar el método listIterator()

Sintaxis: 

public ListIterator listIterator()

Parámetros: este método no acepta argumentos de entrada.

Valor devuelto: este método devuelve un objeto ListIterator que se puede usar para atravesar el objeto Vector. Este objeto se puede utilizar para atravesar el objeto Vector. Es bidireccional, por lo que es posible realizar un recorrido tanto hacia adelante como hacia atrás, utilizando next() y previous() respectivamente.

Tipo de retorno: un ListIterator  

// Java Program to reverse order of elements of vector
// using listiterator
 
// Importing Vector and ListIterator classes
// of java.util package
import java.util.Vector;
import java.util.ListIterator;
 
// Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Create(Declare) empty vector
        Vector<String> v1 = new Vector<String>();
 
        // Add elements to vector using add() method
        v1.add("Geeks");
        v1.add("for");
        v1.add("Geeks");
        v1.add("is");
        v1.add("Best");
 
        // Print message
        System.out.print("Before: ");
 
        // Printing all elements of Vector before reversing
        System.out.println(v1);
 
        // Declare list iterator
        ListIterator<String> l_itr
            = v1.listIterator(v1.size());
 
        // Iistiterator to reverse the vector element using
        // hashPrevious() method
       
      // Print message
        System.out.println("After: ");
       
        while (l_itr.hasPrevious())
           
          // Print vector elements after reversing
            System.out.println(l_itr.previous());
    }
}

Before: [Geeks, for, Geeks, is, Best]
After: 
Best
is
Geeks
for
Geeks