Skip to main content

Random Numbers in Java


In this post we will go through the basics of generating random numbers and also see how they can be generated within a range along with best practices.
Java provides support to either generate random numbers through java.lang.Math package or java.util.Random.

  • Using java.lang.Math

    There exists a static method inside this class, Math.random. It is very convenient to use and returns a double between the range 0.0 and 1.0 i.e. it returns a floating point number between 0 and 1. 
    
public static void main(String[] args){
    double randNum = Math.random();
    System.out.println(randNum);
}

    Random number within a range -

    To generate a random number within a range we need to further process the number returned by Math.random()
    
 public static void main (String[] args){
     double min = 10.0;
     double max = 100.0;
     double randNum = randRange(min, max);
     System.out.println(randNum);
 }
 
 public static double randRange(double min, double max){
     double x = (Math.random()*((max-min)+1))+min;
     return x;
 }
    This code produces a random double between the range 10 to 100.
    With slight modification it can be made to return an integer. 
    
     public static void main (String[] args){
         int min = 10;
         int max = 100;
         int randNum = randRange(min, max);
         System.out.println(randNum);
     }
 
 public static int randRange(int min, int max){
     int x = (int) (Math.random()*((max-min)+1))+min;
     return x;
 }

  • Using java.util.Random

    As java.util.Random is a class, we need to create an object before using it. This class has multiple methods like nextDouble(), nextInt() etc. which makes it easy to generate random numbers to our requirement.
    The following snippet produces a random double between 0 and 1 similar to Math.random()
    
     public static void main (String[] args){
         Random rand = new Random(System.currentTimeMillis());
         System.out.println(rand.nextDouble());
     }
    Usually, the constructor, i.e. Random rand = new Random(System.currentTimeMillis()); can also be used without the System.currentTimeMillis(). This is an optional argument and acts as a seed. It's fine if you just use Random rand = new Random(); but it's better to use with the seed. Theoretically, the seed could be any number.

    Generating a random integer - 

    
     public static void main (String[] args){
         Random rand = new Random(System.currentTimeMillis());
         int randNum = rand.nextInt();
         System.out.println(randNum);
     }

    Random integer between 0 and another number - 

    
     public static void main (String[] args){
         Random rand = new Random(System.currentTimeMillis());
         int max = 1000;
         int randNum = rand.nextInt(max);
         System.out.println(randNum);
     }

    Random integer between a range - 

    
     public static void main (String[] args){
         Random rand = new Random(System.currentTimeMillis());
         int max = 1000;
         int min = 500;
         int randNum = r.nextInt((max - min) + 1) + min;
         System.out.println(randNum);
     }

Comments

Post a Comment

Popular Posts

Evaluating expressions using Stacks | Dijkstra's Two-Stack Algorithm

We are going to look at Dijkstra's two-stack algorithm and see how it's implemented. This algorithm is used to evaluate infix expressions. It uses stacks at its core, so if you don't know about stacks or if you'd want to learn more about them, click this link There are three types of expressions, Infix : Infix expressions are the ones where the operators are used between values, like a + b - c . Postfix : These are the expressions where operators are written after the values, like a b c +- , this translates to a + b - c in infix. Prefix : In these expressions, the operators are written before the values, for example + - a b c . This expression will also be equal to a + b - c in infix. Okay, so what this algorithm does is evaluate expressions like ( ( 3 + 4 ) * 83 ) . It starts by breaking down this expression into a list of stings and create two empty stack, one for housing the values and other for the operators. Then we go through the list one by one. Whenev...
Post a Comment
Read more

Lambda functions in Python

Lambda functions are simply functions that don't have a name. They are also called anonymous functions and are pretty useful for certain cases. They are extensively used in functional programming . Lambda expression is useful for creating small, one time use functions though the functions can also be given a name. It can have multiple arguments but just a single expression as the function body. The basic syntax to create a lambda function is lambda arguments: function body For example lambda x : x **2 This function takes in x and returns x 2 . Here, lambda is the keyword, x is the argument and the expression after the colon is the function body. These functions can also be given a name, sqr = lambda x : x **2 sqr(5) #output : 25 Multiple arguments can also be provided lambda x,y: x * y or lambda x,y,z: x*y*z These functions when given a name are equivalent to the functions defined by using the def keyword. For example def solve_quad(a,b,c): d = b**2 - (4*a*c) x1 ...
1 comment
Read more

Balanced Brackets | Stacks

In this post we will explore and implement an algorithm which helps us verify that if the brackets are balanced or validly used. This is a very important application of stacks as a lot of programming languages use brackets very extensively in their syntax and one of the job of a compiler is to check if the brackets are balanced or not. For simplicity's sake we will just use a list with the methods append() and pop(). This will help us emulate a stack without actually needing to implement it. If you want to, you can go and learn about stacks on this link . A set of brackets can be called balanced if all of the brackets in it are properly matched. Examples of balanced brackets : (([]{}{})) ({{}}[]) Examples of unbalanced brackets : (([)]) {{}]}]]) So now getting to the algorithm, what we simply do is that we go through a string of brackets and check that for every closing bracket there is a properly nested opening bracket. This is how we do it - Convert the input string into a...
Post a Comment
Read more

Tuple data structure in Python

Tuple is a linear data structure which more or less behaves like a python list but with a really important difference, that a tuple is immutable . Immutable means that this structure can't be changed after it has been created, it can't be mutated if I may. Tuples being immutable are more memory efficient than list as they don't over allocate memory . Okay, so what this means is, when a list is created it takes up and reserves extra spaces of memory than needed for the original elements as new elements might be added to the list later and allocating memory on every addition would be quite inneficient but tuples, once created surelly won't change the numbers of elements in it later on, so it allocates exactly how much memory is needed. Almost all the list operations work for tuples except the ones which mutate it, for example, insert, append, remove etc. Declaring a tuple : Tuples can be initialise in a manner similar to list, But there's an important c...
2 comments
Read more

Fast Multiplication of Long Integeres | Karatsuba's Algorithm

This article is divided into 3 parts, so feel free to skip around to the part you find useful - Need for the algorithm Intuition and Algorithm Implementation Need for the algorithm Multiplication is an elementary concept known to all of us since a very early age. But multiplication of very large numbers becomes a difficult problem that can't be solved mentally unless you're a mathematical genius and hence we use calculators and computers. Computers too can efficiently multiply numbers but as the length of digits of the number increases, the time complexity also increases along with it quadratically. To calculate the product of humongous numbers we need a better algorithm. Any algorithm that even slightly increases the runtime will prove to be very beneficial for large values of n, say 100000. Karatsuba multiplication algorithm brings down the number of operations by a factor of one and gives a huge boost. Intuition and Algorithm Okay so, to boost up the speed of...
1 comment
Read more

Kattis | The coding platform

Recently I came across a new website for competitive coding, Kattis and I love it. It is such an amazing platform and has a plethora of question along with multiple long duration contests. The quality of questions is also good and the interface is also very intutive. Follow this link to go to Kattis .
Post a Comment
Read more

Coding questions on Stack and Queue

If you want to learn about Stack or Queue, follow the link to the tutorials- Queue Stack Questions- Maximum Element Equal Stacks Balanced brackets Simple Text Editor Queue using two stacks Castle on the grid Stock Span Problem Celebrity Problem Next greater element
Post a Comment
Read more

Searching: Binary Search

Binary Search Okay, so how do you think we can search for a paticular element in an array? One obvious way will be to loop through the array and return true at which the element is found and to return false if it doesn't exist in the array. But the problem with this algorithm known as linear search is that it can very quickly turn out to be very costly in terms of space and time as this algorithm takes O(n) or linear time. This turns out to be highly costly for a large number of elements in an array. #Linear Search --> def linear_search(array , n ): for i in array: if i == n : return True So, the solution to this is to use an algorithm called binary search . Binary search is an algorithm that works on the divide and conquer technique and is also extremely efficient.It works on O(logn). But the only catch to this algorithm is that the array it is being applied on needs to be sorted . #Binary Search --> def binary_search(array, n ): #Setting up search ...
Post a Comment
Read more

How to develop programming logic?

Definite way to develop programming logic Well,first of all what is programming logic exactly? According to me,it is the ability to efficiently apply programming constructs and techniques to solve a problem. So,the question now is, how do you develop programming logic? Almost every programmer starting out gets stuck in this vortex when you learn the basic constructs but have absolutely no idea how to apply them or how to make things with it.Today all your questions will be answered. Programming Techniques, Right now you're probabaly always approaching problems with a brute force ideology. Now: Start researching and learning techniques like - Divide and Conquer Dynamic Programming Backtracking Greedy Algorithms These techniques definitely will make your life easier as they provide you with new tools in your arsenal to approach problems Algorithms and Data Structures Algorithms and data structures are the most core of Computer Science . All the computation...
Post a Comment
Read more