如何有效地仅生成奇数（或偶数）随机数？

Question

From looking at other questions regarding the generation of only even or odd numbers, I was curious as to what method would be the most efficient (in terms of speed).

For example, let's say that I wanted to generate many odd numbers that range from 1 (inclusive) to 1000 (exclusive); for each iteration, the method I would normally use is the following:

• Generate a random number between 0 (inclusive) and 500 (exclusive)
• Multiply by 2
• Add 1

Is there any better method?

Answer 1

I happened to stumble upon this method today and I can't find any use of it on StackOverflow for generating only even or odd numbers.

This method takes advantage of the fact that, in binary, all even numbers (including 0 ) have their least-significant bit set to 0 whereas all odd numbers have their least-significant bit set to 1 .

Therefore, to generate an odd number, we can simply generate a random number within the desired range and bitwise-or it with 1 :

ThreadLocalRandom.current().nextInt(0, 1_000) | 1

With this method, if the generator selects an odd number, then it is left alone. However, if an even number is selected, then bitwise-or'ing it with 1 essentially increments it.

Likewise, to generate even numbers between 2 (inclusive) and 1000 (exclusive), then we just need to clear the least-significant bit. To do this, we can simply bitwise-and the value with -2 :

ThreadLocalRandom.current().nextInt(2, 1_000) & -2

With this method, if the generator selects an even number, then it is left alone. However, if an odd number is selected, then bitwise-and'ing it with -2 essentially decrements it.

These methods work perfectly fine with negative values, and long as well.

Here is a JMH benchmark comparing the two methods for generating an odd number between 1 (inclusive) and 1000 (exclusive):

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 20, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Fork(5)
public class MyBenchmark {

    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();

    public static void main(String[] args) throws Exception {
        org.openjdk.jmh.Main.main(args);
    }

    @Benchmark
    public int oldMethod() {
        return RANDOM.nextInt(0, 500) * 2 + 1;
    }

    @Benchmark
    public int newMethod() {
        return RANDOM.nextInt(0, 1000) | 1;
    }
}

And the results:

Benchmark              Mode  Cnt  Score   Error  Units
MyBenchmark.newMethod  avgt  100  6.079 ± 0.137  ns/op
MyBenchmark.oldMethod  avgt  100  6.325 ± 0.009  ns/op

oldMethod can be improved slightly by using << 1 instead of * 2 , but newMethod is still slightly faster.

Answer 2

Your 2n + 1 approach is good. You can use streams and wrap it up in a helper method for ease of use if you like:

import java.util.Random;

public static IntStream randomOdds(int from, int upTo) {
    return new Random().ints(from/2, upTo/2).map(n -> 2*n + 1);
}

Usage:

randomOdds(1, 1000).limit(20).forEach(System.out::println);