# Generating random BigIntegers

suggest changeThe `BigInteger`

class has a constructor dedicated to generate random `BigIntegers`

, given an instance of `java.util.Random`

and an `int`

that specifies how many bits will the `BigInteger`

have. Its usage is quite simple - when you call the constructor `BigInteger(int, Random)`

like this:

`BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);`

then you’ll end up with a `BigInteger`

whose value is between 0 (inclusive) and 2`bitCount`

(exclusive).

This also means that `new BigInteger(2147483647, sourceOfRandomness)`

may return all positive `BigInteger`

s given enough time.

What will the `sourceOfRandomness`

be is up to you. For example, a `new Random()`

is good enough in most cases:

`new BigInteger(32, new Random());`

If you’re willing to give up speed for higher-quality random numbers, you can use a new SecureRandom() instead:

```
import java.security.SecureRandom;
// somewhere in the code...
new BigInteger(32, new SecureRandom());
```

You can even implement an algorithm on-the-fly with an anonymous class! Note that **rolling out your own RNG algorithm ****will**** end you up with low quality randomness**, so always be sure to use an algorithm that is proven to be decent unless you want the resulting `BigInteger`

(s) to be predictable.

```
new BigInteger(32, new Random() {
```
int seed = 0;
@Override
protected int next(int bits) {
seed = ((22695477 * seed) + 1) & 2147483647; // Values shamelessly stolen from Wikipedia
return seed;
}
```
});
```