열거 형에서 임의의 값을 선택 하시겠습니까?

내가 이와 같은 열거 형을 가지고 있다면 :

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

무작위로 하나를 선택하는 가장 좋은 방법은 무엇입니까? 생산 품질의 방탄 일 필요는 없지만 상당히 고른 분포가 좋을 것입니다.

나는 이런 식으로 할 수 있습니다

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

그러나 더 좋은 방법이 있습니까? 나는 이것이 이전에 해결 된 것 같은 느낌이 든다.

내가 제안하는 유일한 것은 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));
  }
}

단일 임의의 열거 형에 필요한 모든 방법은 다음과 같습니다.

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

의 제안을 결합 클리 터스 와 헬리오스를 ,

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

간단한 코 틀린 솔루션

MyEnum.values().random()

random()기본 Kotlin에 포함 된 기본 확장 기능 Collection입니다. 코 틀린 문서 링크

확장 기능으로 단순화하려면 다음을 시도하십시오.

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

배열에서 임의의 값을 선택하는 기능을 갖는 것이 가장 쉽습니다. 이것은보다 일반적이며 간단합니다.

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

테스트를 위해이 작업을 수행하면 빠른 검사를 사용할 수 있습니다 ( 이것은 내가 작업 한 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
}

빠른 검사의 장점은 일반 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());
    }
}