Choisissez une valeur aléatoire dans une énumération?

Si j'ai une énumération comme celle-ci:

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

Quelle est la meilleure façon d'en choisir un au hasard? Il n'a pas besoin d'être à l'épreuve des balles de qualité de production, mais une distribution assez uniforme 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 y a-t-il une meilleure façon? J'ai l'impression que c'est quelque chose qui a déjà été résolu.

La seule chose que je suggérerais est de mettre en cache le résultat, values()car chaque appel copie un tableau. De plus, ne créez pas de fichier à Randomchaque fois. Gardez-en un. A part ça, ce que vous faites est bien. Alors:

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

Une seule méthode est tout ce dont vous avez besoin pour toutes vos énumérations 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();

Combinant les suggestions de cletus et helios ,

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>>.

Une seule ligne

return Letter.values()[new Random().nextInt(Letter.values().length)];

D'accord avec Stphen C & helios. Le meilleur moyen d'extraire un élément aléatoire d'Enum est:

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

  private static final Letter[] VALUES = values();
  private static final int SIZE = VALUES.length;
  private static final Random RANDOM = new Random();

  public static Letter getRandomLetter()  {
    return VALUES[RANDOM.nextInt(SIZE)];
  }
}

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

C'est probablement le moyen le plus concis d'atteindre votre objectif. Tout ce que vous avez à faire est d'appeler Letter.getRandom()et vous obtiendrez une lettre d'énumération aléatoire.

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

    public static Letter getRandom() {
        return values()[(int) (Math.random() * values().length)];
    }
}

Solution Kotlin simple

MyEnum.values().random()

random()est une fonction d'extension par défaut incluse dans la base Kotlin sur l' Collectionobjet. Lien vers la documentation Kotlin

Si vous souhaitez le simplifier avec une fonction d'extension, essayez ceci:

inline fun <reified T : Enum<T>> random(): T = enumValues<T>().random()

// Then call
random<MyEnum>()

Pour le rendre statique sur votre classe enum. Assurez-vous d'importer my.package.randomdans votre fichier enum

MyEnum.randomValue()

// Add this to your enum class
companion object {
    fun randomValue(): MyEnum {
        return random()
    }
}

Si vous devez le faire à partir d'une instance de l'énumération, essayez cette extension

inline fun <reified T : Enum<T>> T.random() = enumValues<T>().random()

// Then call
MyEnum.VALUE.random() // or myEnumVal.random() 

Il est probablement plus simple d'avoir une fonction pour choisir une valeur aléatoire dans un tableau. C'est plus générique et simple à appeler.

<T> T randomValue(T[] values) {
    return values[mRandom.nextInt(values.length)];
}

Appelez comme ça:

MyEnum value = randomValue(MyEnum.values());

Voici une version qui utilise shuffle et streams

List<Direction> letters = Arrays.asList(Direction.values());
Collections.shuffle(letters);
return letters.stream().findFirst().get();

Si vous faites cela pour tester, vous pouvez utiliser Quickcheck ( c'est un port 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 type, les collections, les différentes fonctions de distribution, les limites, etc. Il prend en charge les coureurs exécutant plusieurs valeurs:

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 TDD simple fonctionne avec des scénarios.

Il est facile d'implémenter une fonction aléatoire sur l'énumération.

public enum Via {
    A, B;

public static Via viaAleatoria(){
    Via[] vias = Via.values();
    Random generator = new Random();
    return vias[generator.nextInt(vias.length)];
    }
}

et puis tu l'appelles depuis la classe dont tu as besoin comme ça

public class Guardia{
private Via viaActiva;

public Guardia(){
    viaActiva = Via.viaAleatoria();
}

J'utiliserais ceci:

private static Random random = new Random();

public Object getRandomFromEnum(Class<? extends Enum<?>> clazz) {
    return clazz.values()[random.nextInt(clazz.values().length)];
}

Je suppose que cette méthode de retour sur une seule ligne est suffisamment efficace pour être utilisée dans un travail aussi simple:

public enum Day {
    SUNDAY,
    MONDAY,
    THURSDAY,
    WEDNESDAY,
    TUESDAY,
    FRIDAY;

    public static Day getRandom() {
        return values()[(int) (Math.random() * values().length)];
    }

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