列挙型からランダムな値を選びますか？

私がこのような列挙型を持っている場合：

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

ランダムに1つを選択する最良の方法は何ですか？本番品質の完全なものである必要はありませんが、かなり均等に配布することをお勧めします。

私はこのようなことができました

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

しかし、もっと良い方法はありますか？これは以前に解決された問題だと思います。

私が提案する唯一のことはvalues()、各呼び出しが配列をコピーするため、結果をキャッシュすることです。また、Random毎回作成しないでください。1つ保持します。それ以外はあなたがやっていることで結構です。そう：

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

すべてのランダム列挙型に必要なのは1つのメソッドだけです。

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

どちらを使用するか：

randomEnum(MyEnum.class);

また、SecureRandomを次のように使用することを好みます。

private static final SecureRandom random = new SecureRandom();

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

編集：おっと、境界型パラメーターを忘れてしまいました<E extends Enum<E>>。

単線

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

Stphen C＆heliosに同意します。Enumからランダムな要素を取得するより良い方法は次のとおりです。

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

これはおそらくあなたの目標を達成するための最も簡潔な方法ですLetter.getRandom()。

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

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

配列からランダムな値を選択する関数を用意するのがおそらく最も簡単です。これはより一般的で、簡単に呼び出すことができます。

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

次のように呼び出します。

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

ここでは、シャッフルとストリームを使用するバージョン

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

シンプルなKotlinソリューション

MyEnum.values().random()

random()CollectionオブジェクトのベースKotlinに含まれるデフォルトの拡張関数です。Kotlinドキュメンテーションリンク

拡張関数を使ってそれを単純化したい場合は、これを試してください：

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

// Then call
random<MyEnum>()

列挙型クラスで静的にする。my.package.randomenumファイルにインポートしてください

MyEnum.randomValue()

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

列挙型のインスタンスから実行する必要がある場合は、この拡張機能を試してください

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

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

テストのためにこれを行う場合、Quickcheckを使用できます（これは私が取り組んでいるJavaポートです）。

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

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

すべてのプリミティブ型、型構成、コレクション、さまざまな分布関数、境界などをサポートしています。複数の値を実行するランナーをサポートしています。

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

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

Quickcheckの利点は、プレーンTDDがシナリオで機能する仕様に基づいてテストを定義できることです。

列挙型にランダム関数を実装する方が簡単です。

public enum Via {
    A, B;

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

そして、あなたはあなたがこのようにそれを必要とするクラスからそれを呼び出す

public class Guardia{
private Via viaActiva;

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

私はこれを使います：

private static Random random = new Random();

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

この単一行を返すメソッドは、このような単純なジョブで使用するのに十分効率的だと思います。

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