Random number with Probabilities

Yours is a pretty good way already and works well with any range.

Just thinking: another possibility is to get rid of the fractions by multiplying with a constant multiplier, and then build an array with the size of this multiplier. Multiplying by 10 you get

P(1) = 2P(2) = 3P(3) = 5

Then you create an array with the inverse values -- '1' goes into elements 1 and 2, '2' into 3 to 6, and so on:

P = (1,1, 2,2,2, 3,3,3,3,3);

and then you can pick a random element from this array instead.

(Add.) Using the probabilities from the example in kiruwka's comment:

int[] numsToGenerate           = new int[]    { 1,   2,    3,   4,    5   };double[] discreteProbabilities = new double[] { 0.1, 0.25, 0.3, 0.25, 0.1 };

the smallest multiplier that leads to all-integers is 20, which gives you

2, 5, 6, 5, 2

and so the length of numsToGenerate would be 20, with the following values:

1 12 2 2 2 23 3 3 3 3 34 4 4 4 45 5

The distribution is exactly the same: the chance of '1', for example, is now 2 out of 20 -- still 0.1.

This is based on your original probabilities all adding up to 1. If they do not, multiply the total by this same factor (which is then going to be your array length as well).

Some time ago I wrote a helper class to solve this issue. The source code should show the concept clear enough:

public class DistributedRandomNumberGenerator {    private Map<Integer, Double> distribution;    private double distSum;    public DistributedRandomNumberGenerator() {        distribution = new HashMap<>();    }    public void addNumber(int value, double distribution) {        if (this.distribution.get(value) != null) {            distSum -= this.distribution.get(value);        }        this.distribution.put(value, distribution);        distSum += distribution;    }    public int getDistributedRandomNumber() {        double rand = Math.random();        double ratio = 1.0f / distSum;        double tempDist = 0;        for (Integer i : distribution.keySet()) {            tempDist += distribution.get(i);            if (rand / ratio <= tempDist) {                return i;            }        }        return 0;    }}

The usage of the class is as follows:

DistributedRandomNumberGenerator drng = new DistributedRandomNumberGenerator();drng.addNumber(1, 0.3d); // Adds the numerical value 1 with a probability of 0.3 (30%)// [...] Add more valuesint random = drng.getDistributedRandomNumber(); // Generate a random number

Test driver to verify functionality:

    public static void main(String[] args) {        DistributedRandomNumberGenerator drng = new DistributedRandomNumberGenerator();        drng.addNumber(1, 0.2d);        drng.addNumber(2, 0.3d);        drng.addNumber(3, 0.5d);        int testCount = 1000000;        HashMap<Integer, Double> test = new HashMap<>();        for (int i = 0; i < testCount; i++) {            int random = drng.getDistributedRandomNumber();            test.put(random, (test.get(random) == null) ? (1d / testCount) : test.get(random) + 1d / testCount);        }        System.out.println(test.toString());    }

Sample output for this test driver:

{1=0.20019100000017953, 2=0.2999349999988933, 3=0.4998739999935438}

You already wrote the implementation in your question. ;)

final int ran = myRandom.nextInt(100);if (ran > 50) { return 3; }else if (ran > 20) { return 2; } else { return 1; }

You can speed this up for more complex implementations by per-calculating the result on a switch table like this:

t[0] = 1; t[1] = 1; // ... one for each possible resultreturn t[ran];

But this should only be used if this is a performance bottleneck and called several hundred times per second.