Choisir une valeur aléatoire dans un enum ?

Question

Si j'ai un enum comme ceci :

public enum Letter {
    A,
    B,
    C,
    //...
}

Quelle est la meilleure façon d'en choisir un au hasard ? Il n'est pas nécessaire que la qualité de la production soit irréprochable, mais une distribution assez égale serait bien.

Je pourrais faire quelque chose comme ça

private Letter randomLetter() {
    int pick = new Random().nextInt(Letter.values().length);
    return Letter.values()[pick];
}

Mais existe-t-il un meilleur moyen ? J'ai l'impression que c'est quelque chose qui a déjà été résolu auparavant.

Answer 1

La seule chose que je suggérerais est de mettre en cache le résultat de values() car chaque appel copie un tableau. De même, ne créez pas de Random à chaque fois. Gardez-en un. A part ça, ce que tu fais est bien. Donc :

public enum Letter {
  A,
  B,
  C,
  //...

  private static final List<Letter> VALUES =
    Collections.unmodifiableList(Arrays.asList(values()));
  private static final int SIZE = VALUES.size();
  private static final Random RANDOM = new Random();

  public static Letter randomLetter()  {
    return VALUES.get(RANDOM.nextInt(SIZE));
  }
}

Answer 2

Une seule méthode suffit pour tous vos enums aléatoires :

    public static <T extends Enum<?>> T randomEnum(Class<T> clazz){
        int x = random.nextInt(clazz.getEnumConstants().length);
        return clazz.getEnumConstants()[x];
    }

Que vous utiliserez :

randomEnum(MyEnum.class);

Je préfère également utiliser SecureRandom comme :

private static final SecureRandom random = new SecureRandom();

Answer 3

En combinant les suggestions de cletus y hélios ,

import java.util.Random;

public class EnumTest {

    private enum Season { WINTER, SPRING, SUMMER, FALL }

    private static final RandomEnum<Season> r =
        new RandomEnum<Season>(Season.class);

    public static void main(String[] args) {
        System.out.println(r.random());
    }

    private static class RandomEnum<E extends Enum<E>> {

        private static final Random RND = new Random();
        private final E[] values;

        public RandomEnum(Class<E> token) {
            values = token.getEnumConstants();
        }

        public E random() {
            return values[RND.nextInt(values.length)];
        }
    }
}

Edit : Oops, j'ai oublié le paramètre de type borné, <E extends Enum<E>> .

Answer 4

Letter lettre = Letter.values()[(int)(Math.random()*Letter.values().length)];

Answer 5

Si vous faites cela pour tester, vous pouvez utiliser Quickcheck ( Voici un portage Java sur lequel j'ai travaillé. ).

import static net.java.quickcheck.generator.PrimitiveGeneratorSamples.*;

TimeUnit anyEnumValue = anyEnumValue(TimeUnit.class); //one value

Il prend en charge tous les types primitifs, la composition de types, les collections, les différentes fonctions de distribution, les limites, etc. Il supporte les runners exécutant des valeurs multiples :

import static net.java.quickcheck.generator.PrimitiveGeneratorsIterables.*;

for(TimeUnit timeUnit : someEnumValues(TimeUnit.class)){
    //..test multiple values
}

L'avantage de Quickcheck est que vous pouvez définir des tests basés sur une spécification où le simple TDD fonctionne avec des scénarios.