Comment choisir au hasard un élément dans un tableau

Je recherche une solution pour choisir un nombre au hasard dans un tableau d'entiers.

Par exemple, j'ai un tableau new int[]{1,2,3}, comment puis-je choisir un nombre au hasard?

public static int getRandom(int[] array) {
    int rnd = new Random().nextInt(array.length);
    return array[rnd];
}

Vous pouvez utiliser le générateur Random pour générer un index aléatoire et renvoyer l'élément à cet index:

//initialization
Random generator = new Random();
int randomIndex = generator.nextInt(myArray.length);
return myArray[randomIndex];

Si vous allez recevoir un élément aléatoire plusieurs fois, vous voulez vous assurer que votre générateur de nombres aléatoires n'est initialisé qu'une seule fois.

import java.util.Random;

public class RandArray {
    private int[] items = new int[]{1,2,3};

    private Random rand = new Random();

    public int getRandArrayElement(){
        return items[rand.nextInt(items.length)];
    }
}

Si vous choisissez des éléments de tableau aléatoires qui doivent être imprévisibles, vous devez utiliser java.security.SecureRandom plutôt que Random. Cela garantit que si quelqu'un connaît les derniers choix, il n'aura aucun avantage à deviner le suivant.

Si vous cherchez à choisir un nombre aléatoire dans un tableau Object à l'aide de génériques, vous pouvez définir une méthode pour le faire (Source Avinash R dans l' élément Random du tableau de chaînes ):

import java.util.Random;

public class RandArray {
    private static Random rand = new Random();

    private static <T> T randomFrom(T... items) { 
         return items[rand.nextInt(items.length)]; 
    }
}

utilisez java.util.Randompour générer un nombre aléatoire entre 0 et la longueur du tableau:, random_numberpuis utilisez le nombre aléatoire pour obtenir l'entier:array[random_number]

Utilisez la classe Random :

int getRandomNumber(int[] arr)
{
  return arr[(new Random()).nextInt(arr.length)];
}

Vous pouvez aussi utiliser

public static int getRandom(int[] array) {
    int rnd = (int)(Math.random()*array.length);
    return array[rnd];
}

Math.random()renvoie un doubleentre 0.0(inclus) à 1.0(exclusif)

Multiplier cela par array.lengthvous donne un doubleentre 0.0(inclus) et array.length(exclusif)

La diffusion en intarrondi vers le bas vous donne un entier entre 0(inclus) et array.length-1(inclus)

Puisque vous avez java 8, une autre solution consiste à utiliser l'API Stream.

new Random().ints(1, 500).limit(500).forEach(p -> System.out.println(list[p]));

Où 1est le plus petit entier généré (inclus) et 500est le plus élevé (exclusif). limitsignifie que votre flux aura une longueur de 500.

 int[] list = new int[] {1,2,3,4,5,6};
 new Random().ints(0, list.length).limit(10).forEach(p -> System.out.println(list[p])); 

L'aléatoire provient du java.utilpackage.

Jetez un œil à cette question:

Comment générer des entiers aléatoires dans une plage spécifique en Java?

Vous voudrez générer un nombre aléatoire de 0 à la longueur de vos entiers - 1. Ensuite, obtenez simplement votre int de votre tableau:

myArray[myRandomNumber];

Java a une classe Random dans le package java.util. En l'utilisant, vous pouvez effectuer les opérations suivantes:

Random rnd = new Random();
int randomNumberFromArray = array[rnd.nextInt(3)];

J'espère que cela t'aides!

package workouts;

import java.util.Random;

/**
 *
 * @author Muthu
 */
public class RandomGenerator {
    public static void main(String[] args) {
     for(int i=0;i<5;i++){
         rndFunc();
     } 
    }
     public static void rndFunc(){
           int[]a= new int[]{1,2,3};
           Random rnd= new Random();
           System.out.println(a[rnd.nextInt(a.length)]);
       }
}

Vous pouvez également essayer cette approche.

public static <E> E[] pickRandom_(int n,E ...item) {
        List<E> copy = Arrays.asList(item);
        Collections.shuffle(copy);
        if (copy.size() > n) {
            return (E[]) copy.subList(0, n).toArray();
        } else {
            return (E[]) copy.toArray();
        }

    }

package io.github.baijifeilong.tmp;

import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Stream;

/**
 * Created by BaiJiFeiLong@gmail.com at 2019/1/3 下午7:34
 */
public class Bar {
    public static void main(String[] args) {
        Stream.generate(() -> null).limit(10).forEach($ -> {
            System.out.println(new String[]{"hello", "world"}[ThreadLocalRandom.current().nextInt(2)]);
        });
    }
}