Random Number Generator in Java
Random Numbers are commonly used in creating applications like Dice for a board game, Gambling Program, etc. Normally, random number generation takes a lot of time. But, in the Java programming language, this can be achieved using three ways. They are addressed in the below section Random Number Generator Functions in Java.
Start Your Free Software Development Course
Web development, programming languages, Software testing & others
Random Number Generator Functions in Java
In Java, Random Numbers can be generated using 3 ways:
- Math.random method
- java.util.Random class
- ThreadLocalRandom class
1. Math.random() Method
Java Math class offers a number of methods to work on calculations such as logarithms, average, exponentiation, etc. random() is one of the methods among them that returns a positive double value within the range of 0.0 and 1.0 where 0.0 is inclusive, and 1.0 is exclusive. This method can be used with or without using parameters. If parameters are given, the random number generated will be within the given parameter’s range.
Example #1
Code:
public class RandomNumber { double num; //Declare a variable num //Method which generates a random number public double randnum() { num=Math.random(); return num; } // Main Method of a program public static void main(String[] args) { //Printing a random number System.out.println("Random Number generated inside main method: "+Math.random()); //Create an object of the class RandomNumber RandomNumber randomobj=new RandomNumber(); //Store the return value obtained from randnum method in a variable randomval double randomval=randomobj.randnum(); //Printing the random number stored in variable randomval System.out.println("Random Number generated inside randomnumber method: "+randomval); } }
Output:
In the above Example, Random Number is generated using the Math.random() method in two ways-Directly applying it inside the main method and calling a method that contains Math.random() using the object. As mentioned in the explanation above, we can see that 2 random numbers are generated within the range of 0.0 and 1.0.
To generate a random number within the range of parameters, the general expression used is mentioned below:
Math.random()* (( maxvalue – minvalue ) +1 ) + minvalue
Example #2
Where maxvalue is the upper bound of the range and min value is the lower bound of the range. For Example, in order to generate a random number between 10 and 20, set the maxvalue as 20 and the minvalue as 10.
Code:
public class RandomNumParameters { public double randomnum(double x,double y)//max value-y, min value-x { double z =(Math.random()*((y-x)+1)+x); //Formula for random number generation within a range return z; } public static void main(String[] args) { RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters double num=ran.randomnum(3.0, 10.0); //Call the Method System.out.println("Random number generated within the range of 3 and 10: "+num ); } }
Output:
2. java.util.Random Class
Java.util.random class generates random numbers of different data types such as float, long, integer, double, Boolean, etc. It is also possible to pass the range of numbers as arguments to generate a random number within that range. In order to use this class, the Random class of java.util must be imported (java.util.Random). Once this class is imported, create an instance and call the methods such as next long(), nextInt(), etc. using that instance.
Example
Code:
//Java program to generate Random numbers using Random class package Sample; import java.util.Random; //import Random Class public class RandomNum { public static void main(String[] args) { Random rand=new Random(); //Create instance of Random class double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable System.out.println("Random Double value: "+ randomnum); } }
Output:
In the above program, a random double value is generated using the method nextDouble().
3. ThreadLocalRandom class
ThreadLocalRandom class is a specialized type of Random class that is introduced in Java version 1.7. ThreadLocalRandom.current().nextInt() is one of the common methods that is used to generate random numbers. It is normally used in multi-threaded applications.
Example
Code:
//Java Program to generate random numbers using ThreadLocalRandom Class import java.util.concurrent.ThreadLocalRandom; public class RandomNumThread { public static void main(String[] args) { //print a random double System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble()); } }
Output:
Generation of Integers
Random integers can be generated using the ThreadLocalRandom class and Random Class. In both cases, a method nextInt() is used for the same:
Example
Code:
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class import java.util.Random; import java.util.concurrent.ThreadLocalRandom; public class RandomInteger { public static void main(String[] args) { Random rnd=new Random(); //Create instance of Random class int randomnum1=rnd.nextInt(); //Random Integer value using Random Class int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30 int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class System.out.println("Random Integer value using Random Class: "+ randomnum1); System.out.println("Random Integer value within the range of 30: "+ randomnum2); System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3); } }
Output:
In the above example, three Random integer type numbers are generated where one of the nextInt() method has 30 as an argument. So, while generating a random number, 30 will be set as the upper limit, and zero (default lower limit)will be set as the lower limit.
Generating Float point Numbers
Similar to generating integer numbers, floating-point numbers can be generated using a method nextFloat(). This method can be used in both Random Class and ThreadLocalRandom Class:
Example
Code:
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class import java.util.Random; import java.util.concurrent.ThreadLocalRandom; public class RandomFloat { public static void main(String[] args) { Random rnd=new Random(); //Create instance of Random class float randomnum1=rnd.nextFloat(); //Random Float value using Random Class float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class System.out.println("Random float value using Random Class: "+ randomnum1); System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2); } }
Output:
Conclusion – Random Number Generator in Java
Java contains a plethora of functions that can be used in programs. This helps in reducing the processing time and lines of code. Random Number Generation is one task where we can use some of these functions. This document covers the different methods to achieve this.
The above is the detailed content of Random Number Generator in Java. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











Java 8 introduces the Stream API, providing a powerful and expressive way to process data collections. However, a common question when using Stream is: How to break or return from a forEach operation? Traditional loops allow for early interruption or return, but Stream's forEach method does not directly support this method. This article will explain the reasons and explore alternative methods for implementing premature termination in Stream processing systems. Further reading: Java Stream API improvements Understand Stream forEach The forEach method is a terminal operation that performs one operation on each element in the Stream. Its design intention is

PHP is a scripting language widely used on the server side, especially suitable for web development. 1.PHP can embed HTML, process HTTP requests and responses, and supports a variety of databases. 2.PHP is used to generate dynamic web content, process form data, access databases, etc., with strong community support and open source resources. 3. PHP is an interpreted language, and the execution process includes lexical analysis, grammatical analysis, compilation and execution. 4.PHP can be combined with MySQL for advanced applications such as user registration systems. 5. When debugging PHP, you can use functions such as error_reporting() and var_dump(). 6. Optimize PHP code to use caching mechanisms, optimize database queries and use built-in functions. 7

PHP and Python each have their own advantages, and the choice should be based on project requirements. 1.PHP is suitable for web development, with simple syntax and high execution efficiency. 2. Python is suitable for data science and machine learning, with concise syntax and rich libraries.

PHP is suitable for web development, especially in rapid development and processing dynamic content, but is not good at data science and enterprise-level applications. Compared with Python, PHP has more advantages in web development, but is not as good as Python in the field of data science; compared with Java, PHP performs worse in enterprise-level applications, but is more flexible in web development; compared with JavaScript, PHP is more concise in back-end development, but is not as good as JavaScript in front-end development.

PHP and Python each have their own advantages and are suitable for different scenarios. 1.PHP is suitable for web development and provides built-in web servers and rich function libraries. 2. Python is suitable for data science and machine learning, with concise syntax and a powerful standard library. When choosing, it should be decided based on project requirements.

PHPhassignificantlyimpactedwebdevelopmentandextendsbeyondit.1)ItpowersmajorplatformslikeWordPressandexcelsindatabaseinteractions.2)PHP'sadaptabilityallowsittoscaleforlargeapplicationsusingframeworkslikeLaravel.3)Beyondweb,PHPisusedincommand-linescrip

Capsules are three-dimensional geometric figures, composed of a cylinder and a hemisphere at both ends. The volume of the capsule can be calculated by adding the volume of the cylinder and the volume of the hemisphere at both ends. This tutorial will discuss how to calculate the volume of a given capsule in Java using different methods. Capsule volume formula The formula for capsule volume is as follows: Capsule volume = Cylindrical volume Volume Two hemisphere volume in, r: The radius of the hemisphere. h: The height of the cylinder (excluding the hemisphere). Example 1 enter Radius = 5 units Height = 10 units Output Volume = 1570.8 cubic units explain Calculate volume using formula: Volume = π × r2 × h (4

The reasons why PHP is the preferred technology stack for many websites include its ease of use, strong community support, and widespread use. 1) Easy to learn and use, suitable for beginners. 2) Have a huge developer community and rich resources. 3) Widely used in WordPress, Drupal and other platforms. 4) Integrate tightly with web servers to simplify development deployment.
