## Java Random giving negative numbers

how to generate random numbers in java within range

java random nextint

how to generate only positive random numbers in java

java random number between negative 1 and 1

math.random java

java random number between 0 and 1

how to generate 10 random numbers in java

I'm having trouble with Javas `Random`

class, if i do this:

Random rng = new Random(seed) // seed == 29 in this example String ss = ""; for(int i = 0; i < 10; i++) { int s = rng.nextInt(); ss += Integer.toString(s); ss +="\n"; }

This is what i get back:

-1169335537 -2076183625 1478047223 1914482305 722089687 2094672350 -1234724057 -1614953544 -321574001 1000360613

From what I have read this should only be returning positive numbers for a start?

This may be a bit far fetched but it couldnt have anything to do with running a 64 bit machine on Windows 7 64 bit?

Any help at all would be awesome need to get this finished for an assignment hand in today!

From the Java docs for `nextInt()`

:

All 232 possible int values are produced with (approximately) equal probability.

One approach is to use the following transform:

s = rng.nextInt() & Integer.MAX_VALUE; // zero out the sign bit

The reason something like this is needed (as opposed to using absolute value or negation) is that `Integer.MIN_VALUE`

is too large in absolute value to be turned into a positive integer. That is, due to overflow, `Math.abs(Integer.MIN_VALUE) == Integer.MIN_VALUE`

and `Integer.MIN_VALUE == -Integer.MIN_VALUE`

. The above transformation preserves the approximately uniform distribution property: if you wrote a generate-and-test loop that just threw away `Integer.MIN_VALUE`

and returned the absolute value of everything else, then the positive integers would be twice as likely as zero. By mapping `Integer.MIN_VALUE`

to zero, that brings the probability of zero into line with the positive integers.

Here is another approach, which may actually be a tiny bit faster (although I haven't benchmarked it):

int s = rng.next(Integer.SIZE - 1); // Integer.SIZE == 32

This will generate an integer with 31 random low-order bits (and 0 as the 32nd bit, guaranteeing a non-negative value). However (as pointed out in the comment by jjb), since `next(int)`

is a `protected`

method of `Random`

, you'll have to subclass `Random`

to expose the method (or to provide a suitable proxy for the method):

public class MyRandom extends Random { public MyRandom() {} public MyRandom(int seed) { super(seed); } public int nextNonNegative() { return next(Integer.SIZE - 1); } }

Another approach is to use a `ByteBuffer`

that wraps a 4-byte array. You can then generate a random four bytes (by calling `nextBytes(byte[])`

), zero out the sign bit, and then read the value as an `int`

. I don't believe this offers any advantage over the above, but I thought I'd just throw it out there. It's basically the same as my first solution (that masks with `Integer.MAX_VALUE`

).

In an earlier version of this answer, I suggested using:

int s = rng.nextInt(Integer.MAX_VALUE);

However, according to the docs this will generate integers in the range 0 (inclusive) to `Integer.MAX_VALUE`

(exclusive). In other words, it won't generate the value `Integer.MAX_VALUE`

. In addition, it turns out that `next(int)`

is always going to be faster than `nextInt(int)`

.

**Java nextInt() generates negative numbers,** Java in its language has dedicated an entire library to Random numbers seeing its importance in day-day programming. The following example shows the usage of java.util.Random.nextInt() Raises Runtime error, as n is negative. Java.util.Random.nextInt() in Java Generating random numbers themselves have a good utility value and having them achieved by the usage of function can prove to be very useful. Java in its language has dedicated an entire library to Random numbers seeing its importance in day-day programming. nextInt() is discussed in this article.

Since there is an equal chance of positive or negative numbers why not just:

Math.abs(rand.nextInt())

Nice and easy!

**Java.util.Random.nextInt() in Java,** Java provides support to generate random numbers primarily through Note: You can pass a range of negative values to generate a random� In this article, we will show you three ways to generate random integers in a range. java.util.Random.nextInt; Math.random; java.util.Random.ints (Java 8) 1. java.util.Random. This Random().nextInt(int bound) generates a random integer from 0 (inclusive) to bound (exclusive). 1.1 Code snippet.

Negative numbers are allowed - maybe you've read of the similar Random method nextInt( int ) which *does* limit the returned values to be zero or greater.

**Random Number Generation in Java,** Generating random numbers in Java is a common task. Once we import the Random class, we can create an object from it which gives us the will return a number that is within the range of values (negative and positive) of� Java provides support for generating random numbers primarily through the java.lang.Math and java.util.Random classes. In this post, I will discuss different ways to generate random numbers based

Check out the documentation for java.util.Random:

http://download.oracle.com/javase/6/docs/api/java/util/Random.html

Are you you trying to get random numbers from 0 to 28? If so, you need to use nextInt(int) as mentioned previously. The seed has no bearing on the range of possible outputs or their relative likelihoods.

**Java Random Number Generation,** No. From the Java documentation: Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value� Random uses bits which I take that the values I'm using could randomly add up to a bit starting with 1 or 0 making it negative or positive. I do remember working with binary and two's complementary back in the day but as I'm sure you can tell that math isn't my strong suite so it takes me breaking things down in my head to understand.

Per the documentation http://download.oracle.com/javase/6/docs/api/java/util/Random.html#nextInt():

Returns the next pseudorandom, uniformly distributed int value from this random number generator's sequence. The general contract of nextInt is that one int value is pseudorandomly generated and returned. All 2^32 possible int values are produced with (approximately) equal probability.

Just multiply by -1 if the value is negative

**Does Random.nextInt(int) return negative values using java ,** Learn how to create random numbers in Java using the math and Note: You can pass a range of negative values to generate a random� Generating random numbers in Java is a common task. It’s frequently used in gambling, cryptography, statistical sampling and other areas where you need to simulate unpredictable behavior. I’ll explain to you how to create random number generator and show few a little bit different ways how to do that.

**Random Number Generation in Java,** Learn different ways of generating random numbers in Java. equal probability. So, it's very likely that we'll get negative numbers: This will give us a number between 0 (inclusive) and parameter (exclusive). So, the bound� Thank you - I have tried that but it does not seem to work. I am using the random numbers from 0 to 100 (inclusive) to populate a multidimensional array; when trying

**Generating Random Numbers,** Java tutorial with example to generate Random numbers, there are is -2^31 to 2^31-1, which consists both positive and negative integers. Don't expect this functionality from Random and do it yourself as you should. One can do pretty much anything with the result - multiply, add (e.g. 2*nextInt(n)+1 for random odd number), use logarithmic scale for musical note frequencies, use a map or enum to obtain random objects

**How to Generate Random Numbers in Java Between ,** In this post, we will write two java programs, first java programs checks whether the specified number is positive or negative. The second program takes. Floating-point zeros can be positive or negative. Java considers positive and negative zeros to be equal numerically. If you attempt to print a floating-point value that has one of these special values, Java converts the value to an appropriate string. Suppose that you execute the following statements: double x = Math.sqrt(-50); // Not a number

##### Comments

- only believe what you read in the javadocs. And (of course)
**read the javadocs**. - Note
`Math.abs`

wont work one time in 2<sup>32</sup>. (And good luck testing that. Hint: Don't use a static mutable object.) - Random.next() is protected, though, so you can't call it directly. You can subclass Random and expose something like nextPositiveInt() which returns next(31) pretty easily.
`Integer.SIZE - 1`

would be slightly nicer.- @CiroSantilli六四事件法轮功纳米比亚胡海峰 - Yes, that would make it clearer where the value came from. I'll update my answer accordingly.
- You really gotta ask yourself, when have you ever needed to generate Integer.MAX_VALUE? Your previous answer was perfectly acceptable
- Isn't
`(-1) >>> 1`

just`Integer.MAX_VALUE`

? I could just use`rng.nextInt() & Integer.MAX_VALUE`

, or am I missing something? - This won't work. From the docs for
`Math.abs(int)`

: "Note that if the argument is equal to the value of`Integer.MIN_VALUE`

, the most negative representable`int`

value, the result is that same value, which is negative." - Then they should have called the method Math.absExceptIfTheArgumentIsEqualToIntegerMinValueInWhichCaseGoodBloodyLuckToYou(int);
- As mentioned by Ted,
`nextInt(Integer.MAXVALUE)`

leaves out`Integer.MAXVALUE`

, so it is somewhat as good as the obvious`Math.abs`

which gets one value wrong (`Integer.MAXVALUE`

).