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

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

结合的建议的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> { 

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

Answer 3

如果你这样做了测试，你可以使用Quickcheck（this is a Java port I've been working on）。

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 
} 

快速检查的优点是，可以定义基于specification的测试，其中普通TDD适用于场景。

Answer 4

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

Answer 5

一个方法是所有你需要为你的所有随机枚举：

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 6

这可能很简单est有一个函数可以从数组中选取一个随机值。这是更通用的，并且很简单。

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

呼叫，像这样：

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

Answer 7

It's eaiser实现对枚举的随机函数。

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 8

与StphenÇ&赫利俄斯同意。更好地从枚举获取随机元素的方法是：

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 9

单线

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

Answer 10

这里使用随机播放和流

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

Answer 11

版本这可能是实现的最简洁的方式你的目标。你需要做的就是致电Letter.getRandom()，你会得到一个随机的枚举信。

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

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

Answer 12

我这样做：

private static Random random = new Random(); 

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