Negative numbers java random

Random Number Generation in Java

Join the DZone community and get the full member experience.

While developing applications, we often need to generate random numbers. 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 on different types of requirements.

Random Numbers Using the Math Class

Java provides the Math class in the java . util package to generate random numbers.

The Math class contains the static Math . random ( ) method to generate random numbers of the double type.

The random ( ) method returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0 . When you call Math . random ( ) , under the hood, a java . util . Random pseudorandom-number generator object is created and used.

You can use the Math . random ( ) method with or without passing parameters. If you provide parameters, the method produces random numbers within the given parameters.

The code to use the Math . random ( ) method:

public static double getRandomNumber()

The getRandomNumber ( ) method uses the Math . random ( ) method to return a positive double value that is greater than or equal to 0.0 and less than 1.0 .

The output of running the code is:

Double between 0.0 and 1.0: SimpleRandomNumber = 0.21753313144345698

Random Numbers Within a Given Range

For generating random numbers between a given a range, you need to specify the range. A standard expression for accomplishing this is:

(Math.random() * ((max - min) + 1)) + min

Let us break this expression into steps:

1. First, multiply the magnitude of the range of values you want to cover by the result that Math . random ( ) produces.

   Math.random() * ( max — min ) returns a value in the range [ 0 , max – min ] where max is excluded. For example, if you want [ 5 , 10 ], you need to cover 5 integer values so you can use Math . random ( ) * 5 . This would return a value in the range [ 0 , 5 ] , where 5 is not included.

2. Next, shift this range up to the range that you are targeting. You do this by adding the min value.

(Math.random() * ( max — min )) + min

But this still does not include the maximum value.

• To get the max value included, you need to add 1 to your range parameter ( max — min ) . This will return a random double within the specified range.

double x = (Math.random()*((max-min)+1))+min;

There are different ways of implementing the above expression. Let us look at a couple of them.

Random Double Within a Given Range

By default, the Math . random ( ) method returns a random number of the type double whenever it is called. The code to generate a random double value between a specified range is:

public static double getRandomDoubleBetweenRange(double min, double max)

You can call the preceding method from the main method by passing the arguments like this.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber 23">The output is this.
 
System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber 60"> 
Random Integer Within a Given Range
 
The code to generate a random integer value between a specified range is this.
 
public static double getRandomIntegerBetweenRange(double min, double max)
 
The preceding getRandomIntegerBetweenRange ( ) method produces a random integer between the given range. As Math . random ( ) method generates random numbers of double type, you need to truncate the decimal part and cast it to int in order to get the integer random number. You can call this method from the main method by passing the arguments as follows:
 
System.out.println("Integer between 2 and 6: RandomIntegerNumber 28">The output is this.
 
Integer between 2 and 6: RandomIntegerNumber = 5
 
Note: You can pass a range of negative values to generate a random negative number within the range.
 
Random Number Generation Using the Random Class
 
You can use the java . util . Random class to generate random numbers of different types, such as int , float , double , long , and boolean .
 
To generate random numbers, first, create an instance of the Random class and then call one of the random value generator methods, such as nextInt ( ) , nextDouble ( ) , or nextLong ( ) .
 
The nextInt ( ) method of Random accepts a bound integer and returns a random integer from 0 (inclusive) to the specified bound (exclusive).
 
The code to use the nextInt ( ) method is this.
 
public static int generateRandomInt(int upperRange)
 
The code to use the nextInt ( ) method to generate an integer within a range is:
 
public static int generateRandomIntIntRange(int min, int max)
 
The nextFloat ( ) and nextDouble ( ) methods allow generating float and double values between 0.0 and 1.0 .
 
The code to use both the methods is:
 
public static double generateRandomDouble() < Random random = new Random(); return random.nextDouble(); >public static float generateRandomFloat()
 
Random Number Generation Features in Java 8
 
Java 8 introduced a new method, ints ( ), in the java . util . Random class. The ints ( ) method returns an unlimited stream of pseudorandom int values. You can limit the random numbers between a specified range by providing the minimum and the maximum values.
 
The code to use the Random . ints ( ) method to generate random integer values within a specified range is this.
 
public static int getRandomNumberInts(int min, int max)
 
The getRandomNumberInts ( ) method generates a stream of random integers between the min (inclusive) and max (exclusive). As ints ( ) method produces an IntStream , the code calls the findFirst ( ) method that returns an OptionalInt object that describes the first element of this stream. The code then calls the getAsInt ( ) method to return the int value in OptionalInt .
 
The code to use the Random . ints ( ) method to generate a stream of specified random integer values is:
 
public static void getStreamOfRandomInts(int num)
 
The code to call the preceding method is:
 
System.out.println("Random int stream: RandomIntStreamofSize 45">The output of the preceding code is:
 
Random int stream: RandomIntStreamofSize = -1861317227 -1205557317 453883217 762357682 1725970934
 
The code to use the Random . ints ( ) method to generate a stream of a specified number of random integer values between a range is:
 
public static void getStreamOfRandomIntsWithRange(int num, int min, int max)
 
The code to call the preceding method is:
 
System.out.println("Random int stream of specified size in range: RandomIntStreamofSizeInRange 48">The output of the preceding code is:
 
Random int stream of specified size in range: RandomIntStreamofSizeInRange = 2 2 3 4 6
 
In addition to ints ( ) , some other frequently used methods that Java 8 introduced to the Random class — which can return a sequential stream of random numbers — are:
 
Summary
 
The java . util . Random class implements what is generally called a linear congruential generator (LCG). It is designed to be fast but does not meet requirements for real-time use, such as use in unique session ID generation on a web server, scientific experiments, cryptography, or lotteries and sweepstakes where a monetary stake is involved. For such scenarios, there are other alternatives, which I will cover in a later post.
 
For the impatient readers, you can have a look at the SecureRandom class and Xorshift random number generators.
 
Also, an interesting resource is random.org, a true random number service that generates randomness via atmospheric noise.
 
Published at DZone with permission of John Thompson , DZone MVB . See the original article here. 
 
Opinions expressed by DZone contributors are their own.
 
Источник
 
Java how to random a negative number java
 
Solution 2: Generate your first value with room at the bottom for a second value to be subtracted, and the second one from a range bounded by the first: The first number will always be strictly larger than the second, by construction, so the difference will always be a positive integer. Solution 1: No, -- the way you are calling it -- does not return negative numbers.
 
Java nextInt() generates negative numbers
 
 
Java nextInt() generates negative numbers
 
 
No, nextInt() -- the way you are calling it -- does not return negative numbers.
 
Your loop that repeatedly subtracts space from endx1 is what's causing endx1 to become negative.
 
 
endx1 can have an initial value between 0 and 319.
 
space can have a value between 0 and 24.
 
x starts at 1000
 
 
Once for each x , you decrease endx1 by space , meaning that it can reach values as low as 0 - (1000 * 24) = -24000 or as high as 319 - (1000 * 0) .
 
So, in essence, your code is an overly elaborate way to assign endx1 a random value between -24000 and 319. Of course it's going to be negative most of the time.
 
Random rnd = new Random(); int posRandomInt = rnd.nextInt( Integer.MAX_VALUE ); 
 
Integer.MAX_VALUE is a constant holding the maximum value an int can have, 2 31 -1.
 
Java - How do I get a random number with a negative, int rand = new Random ().nextInt ( (30 - 20) + 1) + 20 It will return a random number between 30 and 20. However, I need its range to include negative numbers. How would I include negative numbers in the generation? I have tried using math that would be negative, but that resulted in an error.
 
How to ignore negative value in random number generator
 
Your error is because of overflow. A long in Java can only hold values up to 9,223,372,036,854,775,807 .
 
If your program generates a random number bigger than this, you can get a negative value when you try to cram it into a long . You can see this in the Javadoc for BigInteger#longValue():
 
 
 Note that this conversion can lose information about the overall magnitude of the BigInteger value as well as return a result with the opposite sign. 
 
 
Does Java Random method return negative numbers?, No, Random ().nextInt (bound) only produces positive numbers from 0 to the number you have specified. If you want an negative number, you will need to multiply the random number by -1. int number = new Random ().nextInt (bound) * -1; Random ().nextInt () on the other hand can return you a negative …
 
Generating a random number within a range (both positive and negative) in java [duplicate]
 
Show you some code, it only demo the idea:
 
int myRand(int min, int max)
 
Java Random Number Generator, Computer generated random numbers are divided into two categories: true random numbers and pseudo-random numbers. True random numbers are generated based on external factors. For example, generating randomness using surrounding noises. But generating such true random …
 
Subtracting Random numbers [duplicate]
 
Two possible solutions: Just change your total line with a condition to subtract the larger one from the smaller one (unless they're the same, in which case you'll get 0)
 
 int total = (num1 > num2) ? (num1 - num2) : (num2 - num1); 
 
Or just use the absolute value:
 
 int total = java.lang.Math.abs(num1 - num2); 
 
Change the printf as well:
 
 System.out.printf("What is your answer to %d - %d = ?%n", (num1 > num2) ? num1 : num2, (num1 > num2) ? num2 : num1); 
 
The conditionals are just making sure that the bigger number comes before the smaller number, or if they happen to be equal, that they are both listed.
 
Check out http://www.cafeaulait.org/course/week2/43.html for a more thorough explanation of the ? operator.
 
Generate your first value with room at the bottom for a second value to be subtracted, and the second one from a range bounded by the first:
 
int num1 = r.nextInt(MAX - 1) + 2; // produces values from 2 to MAX, inclusive int num2 = r.nextInt(num1 - 1) + 1; // produces values from 1 to (num1 - 1), inclusive 
 
The first number will always be strictly larger than the second, by construction, so the difference will always be a positive integer.
 
Well, with two random numbers in the same range, in random order, either cold be larger and the subtraction could be negative. Either fix how you get the numbers, or fix how they are ordered, or fix how you get their difference; any of these will do the job.
 
How to Generate Random Number in Java, In Java, there is three-way to generate random numbers using the method and classes. Using the random () Method Using the Random Class Using the ThreadLocalRandom Class Using the ints () Method (in Java 8) Using the Math.random () Method The Java Math class has many methods for different …
 
Источник
 
Читайте также:  Iterator for arraylist in java