# nth Prime Number in Java

(Last Updated On: 10/07/2023)

In the vast realm of mathematics, prime numbers hold a special place. They are the building blocks of countless mathematical concepts and algorithms. If you’ve ever wondered about finding the nth prime number using Java, you’ve come to the right place. In this blog, we will delve into the world of prime numbers and explore how to write a Java program to calculate the nth prime number efficiently.

## What is nth Prime Number in Java?

In Java, the “nth Prime Number” refers to finding the prime number that occupies the position of “n” in the sequence of prime numbers. For example, if we want to find the 5th prime number, we are looking for the prime number that comes after 4 prime numbers.

### Example of nth Prime Number in Java

In other words, if we consider the sequence of prime numbers: 2, 3, 5, 7, 11, 13, 17, 19, 23, … the nth prime number is the prime number found at the nth position in this sequence. Read below a few examples of nth prime numbers in Java for a better understanding of the concept:

• The 1st prime number is 2.
• The 3rd prime number is 5.
• The 6th prime number is 13.
• The 10th prime number is 29.
• The 15th prime number is 47.

To find the nth prime number in Java, you can use various algorithms and techniques. One commonly used approach is to iterate through numbers starting from 2 and check if each number is prime. Once you find the nth prime number, you can return it as the result.

For example, to find the 7th prime number using Java, you would iterate through numbers 2, 3, 4, 5, 6, 7, 8, 9, … and so on, until you reach the 7th prime number, which is 17.

Remember that as you increase the value of “n,” finding the nth prime number becomes computationally more intensive. Therefore, utilizing efficient algorithms and optimization techniques can greatly enhance the performance of your program when dealing with larger values of “n.”

Also, read our blog on “ISBN Number in Java“!

## Finds the nth prime number based on user input (Using Basic/ traditional Approach)

```import java.util.Scanner;
{
public static void main(String[] args)
{
//constructor of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.print("Enter the value of n to compute the nth prime number: ");
//reading an integer from the user
int num = sc.nextInt();
int number=1, count=0, i;
while (count < num)
{
number=number+1;
for (i = 2; i <= number; i++)
{
//determines the modulo and compare it with 0
if (number % i == 0)
{
//breaks the loop if the above condition returns true
break;
}
}
if (i == number)
{
//increments the count variable by 1 if the number is prime
count = count+1;
}
}
//prints the nth prime number
System.out.println("The " +num +"th prime number is: " + number);
}
}  ```

Explanation of the code:

1. The program starts by creating a Scanner object to read input from the user.

2. It prompts the user to enter the value of ‘n’, which represents the position of the desired prime number in the sequence.

3. Later the user input is stored in the variable ‘num’.

4. The variables ‘number’, ‘count’, and ‘i’ are declared. ‘number’ is initialized to 1, ‘count’ is set to 0, and ‘i’ will be used in a loop.

5. The while loop continues until the value of ‘count’ is less than ‘num’.

6. The loop increments ‘number’ by 1.

7. Then, a for loop is used to check if ‘number’ is prime. It starts from 2 and iterates up to ‘number’.

8. In each iteration, it checks if ‘number’ is divisible by ‘i’ (using the modulo operator ‘%’). If it is divisible, the loop breaks.

9. If the loop completes without breaking, it means ‘number’ is prime. In this case, ‘count’ is incremented by 1.

10. Finally, outside the loops, the program prints the value of ‘number’, which represents the nth prime number.

This code efficiently finds the nth prime number by iterating through numbers and checking for divisibility.Consequently it demonstrates a basic implementation of finding prime numbers in Java.

Check out our blog on Strontio Number in Java here!

#### Output:

``````Enter the value of n to compute the nth prime number: 10
The 10th prime number is: 29``````

## Find and print all prime numbers within a given range (Using Sieve of Eratosthenes Approach)

```import java.util.*;
class primeNo {

public static void main(String[] args)
{
int from = 1, to = 20, i;
boolean[] a = new boolean[to + 1];
Arrays.fill(a, true);

// 0 and 1 are not prime
a = false;
a = false;
for (i = 2; i <= Math.sqrt(to); i++)

// Check if number is prime
if (a[i])
for (int j = i * i; j <= to; j += i) {
a[j] = false;
}
for (i = from; i <= to; i++) {

// Printing only prime numbers
if (a[i])
System.out.print(" " + i);
}
}
}```

Explanation of the code:

The range is specified using the variables from and to, which represent the starting and ending values of the range, respectively.

The program utilizes the Sieve of Eratosthenes algorithm to determine prime numbers efficiently. It creates a boolean array named a with a size of to + 1 to mark numbers as prime or not. Initially, all elements in the array are set to true.

The program then proceeds to mark non-prime numbers within the range. It starts iterating from 2 up to the square root of to. For each i value, if a[i] is true, it indicates that i is a prime number. Hence, the program marks all the multiples of i as non-prime by setting a[j] to false. In each iteration, we increment j by i to do this.

After marking all non-prime numbers, the program loops through the range from from to to. Afterwards it prints the numbers that correspond to the indices where a[i] is true, indicating that they are prime numbers.

In summary, the code efficiently finds and prints all prime numbers within the given range using the Sieve of Eratosthenes algorithm.

Get complete Java Programming Exercises and Solutions here!

#### Output:

``2 3 5 7 11 13 17 19``

### Optimization techniques for finding nth Prime Number in Java:

When it comes to finding the nth prime number in Java, there are several optimization techniques that can significantly improve the efficiency of the algorithm. By employing these techniques, we can reduce the time complexity and achieve faster results, especially for larger values of n. Let’s explore some of these optimization techniques:

• Sieve of Eratosthenes: The Sieve of Eratosthenes algorithm is a popular approach to generate prime numbers. Instead of checking each number individually, it marks all multiples of a prime number as non-prime. By eliminating multiples, the algorithm reduces the number of iterations required, resulting in faster prime number generation.
• Limiting Search Range: Instead of checking divisibility up to n, we can limit the search range by only checking divisibility up to the square root of n. This is because if a number n is not prime, it must have a factor less than or equal to its square root.
• Skipping Even Numbers (Except 2): Since all even numbers (except 2) are not prime, we can skip checking even numbers during the prime number generation process. By doing so, we reduce the number of iterations by half, leading to faster execution.
• Dynamic Programming: We can implement dynamic programming techniques to store previously calculated prime numbers and reuse them in subsequent calculations. This saves computational time by avoiding redundant calculations.
• Prime Number Theorems: Utilizing prime number theorems, such as the Prime Number Theorem or the Sieve of Atkin, can provide insights into estimating the upper bound of the nth prime number. You can use this estimation to optimize the search range and improve efficiency.

By combining these optimization techniques, we can create a more efficient algorithm to find the nth prime number in Java. These techniques significantly reduce the computation time, allowing us to handle larger values of n while obtaining results in a reasonable timeframe.

In conclusion, exploring Java’s nth prime number reveals mathematical significance. By implementing efficient algorithms and optimization techniques like the Sieve of Eratosthenes, limiting the search range, skipping even numbers, utilizing dynamic programming, and leveraging prime number theorems, we can enhance the performance of our program and calculate prime numbers more efficiently. Explore Java’s prime number techniques for handling larger n values and obtaining reasonable results.

Our blog post on “nth Prime Number in Java” is aimed at answering any Java-related doubts you may have. Visit the Newtum’s website to learn more about our online coding courses in  Java, Python, PHP, and other topics as you continue to develop your coding skills. You can master Java development and learn new programming concepts with practice and dedication.