¿Cómo obtener elementos aleatorios del vector en Java?

Vector en Java es parte del marco de colecciones de Java . Vector es una array dinámica de objetos, es decir, el tamaño del vector se puede modificar según el requisito. Vector implementa lainterfaz List . También mantiene el orden de inserción y se puede acceder a los elementos del vector utilizando sus índices. El vector en java está sincronizado . 

Podemos acceder a los elementos vectoriales de las siguientes formas:

• Usando sus índices
• Usando el iterador
• Llamando aleatoriamente a los elementos del vector

Diferentes formas de obtener elementos aleatorios del vector:

1. Usando el método random() de la clase Math
2. Usando la clase aleatoria
3. Usando la clase ThreadLocalRandom

Método 1: usar el método random() de la clase Math

La clase Math del paquete java.lang tiene un método random() que devuelve un valor doble positivo mayor que 0.0 y menor que 1.0. Podemos usar este método para generar un índice aleatorio y acceder al elemento presente en ese índice en el vector dado.

// Java program to access random elements from the vector
// using random() method of Math class
  
import java.util.Vector;
public class GfG {
    
    // Create an instance of type vector which accepts
    // elements of String type
    static Vector<String> vector;
  
    // getRandomElements() method which accesses random
    // elements from the vector
    static void getRandomElements()
    {
        // Run a loop as many times as the number of
        // elements you want to access
        for (int i = 0; i < vector.size(); i++) 
        {
            // Generate a random int value between 0 and the
            // last index of the vector
            int index = (int)(Math.random() * vector.size());
            
            // get the element at the generated random index
            System.out.println(vector.get(index));
        }
    }
  
    // Driver method
    public static void main(String[] args)
    {
        // Instantiate the vector instance
        vector = new Vector<String>();
        
        // Add elements into the vector
        vector.add("Welcome");
        vector.add("To");
        vector.add("Geeks");
        vector.add("For");
        vector.add("Geeks");
        
        // Call the getElements() method on this vector
        // object
        getRandomElements();
    }
}

For
To
Welcome
Welcome
Geeks

Método 2: Usando la clase Random

Para generar el índice aleatorio también podemos usar la clase Random del paquete java.util . Proporciona métodos útiles para generar números aleatorios del tipo especificado y dentro de rangos especificados.

// Java program to access random elements from the vector
// using random class
  
import java.util.Random;
import java.util.Vector;
class GFG {
    
    // Create a Vector instance of type String
    static Vector<String> vector;
    
    // getRandomElements() method which accesses the
    // random elements from the given vector
    static void getRandomElements()
    {
        // create new object of the Random class
        Random random = new Random();
        
        // Run a loop as many times as the number of
        // elements you want to access
        for (int i = 0; i < vector.size(); i++)
        {
            // call the nextInt() method of this random
            // object to generate a random int value
            int index = random.nextInt(vector.size());
            
            // Get the element present at this random index
            // in the given vector
            System.out.println(vector.get(index));
        }
    }
  
    // Driver method
    public static void main(String[] args)
    {
        // Instantiate the vector object
        vector = new Vector<String>();
        
        // Add elements into the Vector
        vector.add("Welcome");
        vector.add("To");
        vector.add("Geeks");
        vector.add("For");
        vector.add("Geeks");
        
        // Call the getRandomElements() method on this
        // vector object
        getRandomElements();
    }
}

Welcome
Geeks
To
Geeks
For

Método 3: Usar la clase ThreadLocalRandom

La clase ThreadLocalRandom de java.util.concurrent es un generador de números aleatorios aislado del subproceso actual. Genera un número aleatorio de un tipo específico y dentro del rango especificado para cada subproceso en un entorno de subprocesos múltiples. Podemos generar el índice aleatorio usando el método nextInt() de esta clase y acceder al elemento en ese índice desde el vector dado. 

// Java program to access random elements from the given
// vector using ThreadLocalRandom class
  
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
class GFG {
    
    // Create a Vector instance which accepts elements of
    // String type
    static Vector<String> vector;
    
    // getRandomElements() method which accesses random
    // elements from the given vector
    static void getRandomElements()
    {
        // Run a loop as many times as the number of
        // elements you want to access
        for (int i = 0; i < vector.size(); i++) 
        {
            // Generate a random integer by calling the
            // ThreadLocalRandom.current().nextInt() method
            int index = ThreadLocalRandom.current().nextInt(vector.size());
            
            // Print the element present at this random
            // index in the given vector
            System.out.println(vector.get(index));
        }
    }
  
    // Driver method
    public static void main(String[] args)
    {
        vector = new Vector<String>();
        
        // Add elements into the vector
        vector.add("Welcome");
        vector.add("To");
        vector.add("Geeks");
        vector.add("For");
        vector.add("Geeks");
        
        // Call the getRandomElements() method on this
        // vector object
        getRandomElements();
    }
}

Geeks
Welcome
Geeks
To
To