Question

I have an enum that I would like to randomly select a value from, but not truly random. I would like some of the values to be less likely of being selected so far. Here is what I have so far…

private enum Type{
        TYPE_A, TYPE_B, TYPE_C, TYPE_D, TYPE_E;

        private static final List<Type> VALUES =
            Collections.unmodifiableList(Arrays.asList(values()));
          private static final int SIZE = VALUES.size();
          private static final Random RANDOM = new Random();

          public static Type randomType()  {
            return VALUES.get(RANDOM.nextInt(SIZE));
          }
    }

Is there an efficient way of assigning probabilities to each of these values?

Code found from here

Answer 1

several ways to do it, one of them, similar to your approach

private enum Type{
    TYPE_A(10 /*10 - weight of this type*/),
    TYPE_B(1),
    TYPE_C(5),
    TYPE_D(20),
    TYPE_E(7);

    private int weight;
        
    private Type(int weight) {
        this.weight = weight;
    }
    
    private int getWeight() {
        return weight;
    }
    
    private static final List<Type> VALUES =
            Collections.unmodifiableList(Arrays.asList(values()));
    
    
    
    private int summWeigts() {
       int summ = 0;
       for(Type value: VALUES) 
          summ += value.getWeight();
       return summ;
    }
    
    private static final int SIZE = summWeigts();
    private static final Random RANDOM = new Random();
    
    public static Type randomType()  {
        int randomNum = RANDOM.nextInt(SIZE);
        int currentWeightSumm = 0;
        for(Type currentValue: VALUES) {
           if (randomNum > currentWeightSumm && 
               randomNum <= (currentWeightSumm + currentValue.getWeight()) {
             break;
           }
           currentWeightSumm += currentValue.getWeight();
        }
    
        return currentValue.get();
    }
}