从枚举中选择一个随机值？

Question

如果我有一个像这样的枚举：

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

随机选择一个的最佳方法是什么？它不需要是生产质量防弹的，但相当均匀的分布会很好。

我可以做这样的事情

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

但是有更好的方法吗？我感觉这个问题以前就已经解决了。

Answer 1

我唯一建议的是缓存 values() 的结果，因为每个调用都会复制一个数组。另外，不要每次都创建一个Random。保留一个。除此之外，你所做的一切都很好。所以：

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

所有随机枚举都需要一个方法：

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

Answer 3

单线

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

Answer 4

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

编辑：哎呀，我忘记了有界类型参数，>。

Answer 5

简单的 Kotlin 解决方案

MyEnum.values().random()

random() 是基本 Kotlin 中包含在 Collection 对象上的默认扩展函数。 Kotlin 文档链接

如果您想简化它使用扩展函数，请尝试以下操作：

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

// Then call
random<MyEnum>()

使其在枚举类上保持静态。确保在枚举文件中导入 my.package.random

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

Answer 6

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

Answer 7

同意 Stphen C 和 Stphen C 的观点。太阳神。从 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)];
  }
}

Answer 8

最简单的方法可能是使用一个函数从数组中选择一个随机值。这更通用，并且调用起来更简单。

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

像这样调用：

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

Answer 9

这是使用随机播放和流的版本

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

Answer 10

这可能是实现您的目标的最简洁的方法。您所需要做的就是调用 Letter.getRandom()，您将获得一个随机枚举字母。

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

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

Answer 11

如果您这样做是为了测试，您可以使用 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 适用于场景。

Answer 12

我想这个单行返回方法足够有效，可以用于这样一个简单的工作：

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

Answer 13

在枚举上实现随机函数更容易。

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

Answer 14

我会用这个：

private static Random random = new Random();

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

Answer 15

枚举形状颜色{
蓝色的，
黄色的，
红色的，
绿色的，
白色的，
}

    Random random=new Random();
    ShapeColor[] values=ShapeColor.values();
    int size=values.length;
    return values[random.nextInt(size)];

Answer 16

public static Letter randomLetter() {
    return List.of(values()).get(Random.randomInt(List.of(values()).size()));

}