Comment choisir au hasard un élément d'un tableau

Je suis à la recherche d'une solution pour choisir le nombre aléatoire à partir d'un tableau d'entiers.

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

saisir

InformationsquelleAutor BreakHead | 2011-11-09

153
```
public static int getRandom(int[] array) {
    int rnd = new Random().nextInt(array.length);
    return array[rnd];
}
```
- oui, mais vous avez à dire que generator est une instance de java.util.Random
- Fixe. Oups! 🙂
- Je ne voudrais pas créer Random() chaque fois que vous exécutez la fonction: le générateur aléatoire est censé avoir de l'histoire. Si elle ne l'avez pas, il est extrêmement prévisible. Ce n'est pas un problème du tout dans ce cas — mais il doit être mentionné que array[(int)(System.currentTimeMillis() % array.length)] est tout aussi bonne que la solution proposée.
- c'est loin loin d'être aussi bonne que la solution proposée. new Random() tente de créer une instance qui a un autre graine que précédemment créé Random. Votre approche de casser horriblement simplement en appelant la fonction deux fois en peu de temps.
- certains systèmes n'ont pas à l'ordre de la milliseconde d'horloge précis qui peut empêcher certaines options en cas de gcd(array.length,clockAccuracy)!=1
- Eh bien, il n'ont ++seedUniquifier à l'intérieur, et utilise nanoTime() au lieu de currentTimeMillis() — mais il est toujours parfaitement prévisible.
- Note: je n'ai new Random (), précisément en raison de la graine problème que j'ai vécu dans le passé, bien que vous pouvez simplement utiliser setSeed(..) et utiliser un incrémenté var w/ nanotime.
- Je viens de remarquer une notification que j'ai downvoted cette réponse - j'ai cliqué par hasard; malheureusement, l'interface ne me laisse pas le défaire (il dit que je peux pas changer mon vote, sauf si la réponse est édité...). Donc, les excuses de Chris Dennett.
- Je n'aurais pas d'excuses, la création de nouveaux objets est de la merde. C'est ridicule que vous ne pouvez pas créer un nouveau hasard dans un Random facilement
InformationsquelleAutor Chris Dennett
11

Vous pouvez utiliser le générateur Aléatoire de la génération aléatoire d'index et de retour de l'élément à l'index:
```
//initialization
Random generator = new Random();
int randomIndex = generator.nextInt(myArray.length);
return myArray[randomIndex];
```
InformationsquelleAutor Luchian Grigore
8

Si vous êtes va être un élément aléatoire à plusieurs reprises, vous voulez vous assurer que votre générateur de nombre aléatoire 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 êtes la cueillette aléatoire les éléments du tableau qui ont besoin d'être imprévisible, vous devez utiliser java.de sécurité.SecureRandom plutôt qu'au Hasard. Qui assure que si quelqu'un le sait depuis quelques pioches, ils n'ont pas un avantage à deviner la prochaine.

Si vous cherchez à choisir un nombre aléatoire à partir d'un tableau d'Objets à l'aide de médicaments génériques, vous pouvez définir une méthode pour le faire (Source Avinash R dans Élément aléatoire de 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)]; 
    }
}
```
InformationsquelleAutor Stephen Ostermiller
3

utilisation java.util.Random pour générer un nombre aléatoire entre 0 et la longueur du tableau: random_number, et ensuite utiliser le nombre aléatoire pour obtenir le nombre entier: array[random_number]

InformationsquelleAutor James.Xu

Utiliser le Aléatoire classe:

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

InformationsquelleAutor AlQafir

2

Vous pouvez également utiliser
```
public static int getRandom(int[] array) {
    int rnd = (int)(Math.random()*array.length);
    return array[rnd];
}
```
Math.random() retourne un double entre 0.0 (inclus) au 1.0 (exclusif)

Multipliant ce avec array.length vous donne un double entre 0.0 (inclus) et array.length (exclusif)

Casting pour int arrondir vers le bas en vous donnant entier et entre 0 (inclus) et array.length-1 (inclus)
- Les mathématiques.random() renvoie un double, et pas un int. Si il aurait il aurait été tout deux valeurs 0 et 1.
InformationsquelleAutor ratchet freak
1

Puisque vous avez java 8, une autre solution consiste à utiliser le volet de l'API.
```
new Random().ints(1, 500).limit(500).forEach(p -> System.out.println(list[p]));
```
Où 1 est la plus faible int généré (inclus) et 500 est le plus élevé (exclusif). limit signifie que votre flux, vous avez 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])); 
```
Aléatoire est de java.util paquet.

InformationsquelleAutor Johnny Willer
0

Prendre un coup d'oeil à cette question:

Comment puis-je générer des entiers aléatoires dans une gamme spécifique en Java?

Vous souhaitez générer un nombre aléatoire de 0 à votre entiers de longueur - 1. Alors tout simplement obtenir votre int à partir de votre tableau:
```
myArray[myRandomNumber];
```
InformationsquelleAutor Brian DiCasa
0

Java a une au Hasard de classe en java.util paquet. En l'utilisant, vous pouvez effectuer les opérations suivantes:
```
Random rnd = new Random();
int randomNumberFromArray = array[rnd.nextInt(3)];
```
Espérons que cette aide!

InformationsquelleAutor decden

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)]);
       }
}

InformationsquelleAutor

0

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();
        }

    }
```
- Si vous shuffle une liste avec O(nlogn) temps de la complexité, faire de la copie de deux fois à l'aide du total de 3 fois plus de mémoire que la table initiale, même si le problème de l'OP demandé à ce sujet peut être résolu avec O(1) temps de la complexité et de O(1) de la mémoire...?
- oui, vous avez raison, C'était mieux de le faire avec la constante de temps et de l'espace de la complexité.
InformationsquelleAutor Ravi Sapariya

package io.github.baijifeilong.tmp;

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

/**
 * Created by [email protected] 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)]);
        });
    }
}

InformationsquelleAutor BaiJiFeiLong

Vous devez vous connecter pour publier un commentaire.