# Solved: ranfom number between 1 to 100

The generation of random numbers in programming is a common task and is often deployed in a wide range of scenarios such as in simulations, games, cryptography, and – when preparing unique identifiers amongst many more applications. In this article we will be focusing on random number generation in Java programming and specifically, we will be generating random numbers within the range of 1 to 100.

Java programming language provides a wealth of features that enables a developer to perform a myriad of tasks, and a random number generation within a particular range is one of those routines. The core Java library stack includes the java.util.Random class which is leveraged for this particular task.

```import java.util.Random;
Random rand = new Random();
int rand_int = rand.nextInt(100);
```

The code above generates a random number between 0 (inclusive) and the number passed in this method (exclusive), in this instance, 100. However, as our range is meant to start from 1, we will need to adjust the result accordingly as shown in the next code snippet.

## The Solution

Achieving the desired result requires a small tweak of the code. We will generate a random number from 0 to 99 (inclusive) and then we will increase the result by one.

```import java.util.Random;
Random rand = new Random();
// Generate random integers in range 0( inclusive) to 100 (exclusive)
int rand_int = rand.nextInt(100);
// Since our range starts from 1, add 1 to the result
rand_int = rand_int + 1;
```

The java.util.Random class is a staple in Java programming providing pseudorandom number generation. By harnessing the methods provided by this class, numbers can be randomly generated with a few lines of code.

## Explaining the Code

1. Import the java.util.Random class: This is the class in Java that provides for generation of random numbers.

2. Create an instance of the Random class: Random rand = new Random(). This sets up a new random number generator.

3. Generate a random integer: int rand_int = rand.nextInt(100). Here, the nextInt method is invoked on the Random object which generates a random integer. As the number 100 is passed as an argument to the nextInt function, it sets the bound on the random number to be generated. This means that the result could be any of the numbers within the range of 0 to 99 (inclusive).

4. Adjust the result: rand_int = rand_int + 1. Since the nextInt(100) method call can return anything from 0 to 99 and our requirement is for numbers in the range of 1 to 100, we need to add 1 to the result.

With this implementation of Java code, one can easily generate random numbers within the specific range of 1 to 100. The utility of Java’s Random class should not be underestimated given the wide array of applications it has within the field of programming

Related posts: