Prime Number Program in Java: How to Print and Check Prime Numbers?

A prime number is a natural number greater than 1 that has no divisors other than 1 and itself​. In other words, you can’t evenly divide a prime by any smaller positive integer (besides 1). For example, 2, 3, 5, 7, and 11 are prime numbers as they can’t be broken down into smaller factors. 

Now, prime numbers might seem like simple math trivia, but they play a huge role in programming and security. A prime number program in Java is any method used to efficiently identify and work with prime numbers.

In this guide, we’ll demystify primes and explore how to identify prime numbers using a prime number program in Java through various methods – from basic checks to efficient algorithms. Whether you’re a beginner learning loops or an experienced coder curious about optimizing prime checks, we’ve got you covered with multiple implementations. 

How to Print Prime Numbers from 1 to 100 in Java Using the Simple Method? 

Learning to print prime numbers from 1 to 100 using a prime number program in Java is a great way to explore loops, conditional probabilities, and basic algorithmic thinking.

By the end of this, you'll be able to generate all the prime numbers between 1 and 100 and have a solid grasp of how prime number checking works in programming.

Let’s break this down into simple steps and the corresponding algorithm.

Algorithm and Steps

• Initialize a loop to go through each number from 2 to 100
• For each number in the loop, check divisibility
• If the number is divisible by any number from 2 to itself minus 1, it’s not prime
• If no divisors are found, it is a prime number
• Print the prime numbers as you go

Steps for the Program

• Start with a for loop that goes from 2 to 100. The loop will check each number to determine if it’s prime.
• For each number, run another loop that goes from 2 to that number minus 1. If the current number is divisible by any of these, you can stop the check and move on to the next number.
• If no divisors are found, the number is prime, so print it.

Sample Java Code for Prime Numbers 1 to 100

public class PrimeNumber {
    public static void main(String[] args) {
        // Loop through numbers from 2 to 100
        for (int num = 2; num <= 100; num++) {
            boolean isPrime = true;  // Assume the number is prime
            
            // Check divisibility from 2 to num-1
            for (int i = 2; i < num; i++) {
                if (num % i == 0) {  // If divisible, it's not prime
                    isPrime = false;
                    break;
                }
            }
            
            // If the number is still prime, print it
            if (isPrime) {
                System.out.println(num);
            }
        }
}
}

Code Explanation

• The outer loop runs through every number from 2 to 100.
• The inner loop checks if the number is divisible by any number between 2 and the number minus 1.
• If it finds any divisor, the number is not prime, and the program moves to the next number.
• If no divisors are found, the number is prime and gets printed.

Why Does This Work?

This program uses the brute-force prime number program in Java to check primality. For each number, you test whether it can be divided by any number smaller than itself. While this approach is easy and understandable, it’s not the most efficient for large numbers. 

In real-world applications, especially cryptography, more optimized algorithms are used. However, this method works perfectly for smaller ranges like 1 to 100 and is a great way to practice working with loops and conditionals.

Example Output:

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

By following this simple algorithm, you can list all prime numbers between 1 and 100 in just a few lines of Java code for prime numbers from 1 to 100!

Also Read: Coding vs Programming: Difference Between Coding and Programming

Which Methods in Java Check and Print Prime Numbers?

Several approaches help you decide if a number is prime, and each has its own pros and cons. Let’s walk through each method. 

You are free to adapt these methods based on your project’s requirements or constraints.

1. How to Print Prime Numbers Using Brute-Force Prime Number Program in Java? 

The brute-force method is often the first approach people learn. It tests whether any number from 2 to n-1 (or a reduced range) divides the target number. It’s straightforward, though not the most efficient for large inputs.

Code Sample (Brute Force)

public class PrimeCheckBruteForce {
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;  // 0, 1, and negative numbers are not prime
        }
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                return false;  
            }
        }
        return true;  
    }

    public static void main(String[] args) {
        int number = 17;
        if (isPrime(number)) {
            System.out.println(number + " is prime.");
        } else {
            System.out.println(number + " is not prime.");
        }
    }
}

Code Explanation

The program follows a simple step-by-step process to determine whether a number is prime:

• The method isPrime(int n) checks if a number is prime.
• If n <= 1, the function returns false because 0, 1, and negative numbers are not prime.
• A loop runs from 2 to n-1 to check if n is divisible by any number.
• If n % i == 0, it returns false immediately since n is not prime.
• If no divisors are found, the function returns true, meaning n is prime.
• The main method assigns number = 17 and calls isPrime(number).
• If isPrime(number) returns true, it prints "17 is prime.", otherwise it prints "17 is not prime."

Output:

17 is prime.

• The function starts checking 17.
• The loop runs from 2 to 16 and checks if 17 is divisible by any of them.
• Since 17 has no divisors other than 1 and itself, the function returns true, printing "17 is prime."

Time Complexity Analysis
Brute-force checking has a time complexity of O(n) in the worst case. That means if n is 100, you might do up to 98 checks. It’s perfectly fine for small inputs but grows quickly for large n.

When to Use the Brute-force Method?

• Teaching basic programming concepts.
• Running tests on smaller values where performance isn’t critical.

Also Read: Perfect Number Program for Java

2. How to Print Prime Numbers from 1 to 100 Using the Square Root Optimization Prime Number Program in Java?

The square root method optimizes the simple method by limiting the number of divisibility checks. Instead of checking divisibility up to the number itself, you only need to check up to the square root of the number. This significantly reduces the number of checks, especially for larger numbers.

Explanation

A number doesn’t need to be divisible by any number greater than its square root. If a number is divisible by a factor larger than its square root, the corresponding smaller factor would have already been detected. This method dramatically improves efficiency for larger numbers.

Working Algorithm Steps

• Loop through numbers from 2 to 100.
• For each number, check divisibility from 2 to the square root of that number (rounded up).
• If no divisors are found, the number is prime.

Code Sample (Square Root Optimization)

public class PrimeNumber {
    public static void main(String[] args) {
        for (int num = 2; num <= 100; num++) {
            boolean isPrime = true;
            for (int i = 2; i <= Math.sqrt(num); i++) {
                if (num % i == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println(num);
            }
        }
    }
}

Code Explanation

• The loop runs through numbers from 2 to 100.
• For each number, a flag variable isPrime is set to true.
• A second loop checks divisibility only up to √num to optimize performance.
• If the number is divisible by any i within that range, isPrime is set to false, and the loop exits early using break.
• If no divisors are found, isPrime remains true, and the number is printed as a prime number.

Output:

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

• The program correctly prints all prime numbers from 2 to 100.
• Numbers like 4, 6, 8, 9, 10 are skipped because they have divisors within their square root range.
• The early exit (break) prevents unnecessary checks, making it more efficient than checking all numbers up to n.

Time Complexity Analysis
This approach has a worst-case time complexity of O(√n). In practice, you may see big performance improvements compared to the O(n) brute force, especially when n is large.

When to Use the Square Root Optimization Method?

• Situations where n can become moderately large (up to the tens or hundreds of thousands).
• Interview settings and coding challenges where an O(√n) check is acceptable.

3. How to Print Prime Numbers from 1 to 100 Using the 6k ± 1 Prime Number Method in Java? 

The 6k ± 1 method is an optimized approach for finding prime numbers based on mathematical patterns. Instead of checking every number for primality, this method reduces the number of candidates before applying a primality test, making it more efficient than a naive brute-force check.

Why Does the 6k ± 1 Formula Work?

All prime numbers greater than 3 can be expressed as either of the following two:

• 6k - 1
• 6k + 1

Here, k is a positive integer.

This method eliminates numbers that are definitely composite (multiples of 2 or 3) before performing a full prime check.

However, not all numbers of the form 6k ± 1 are prime — they still need to be checked using a primality test.

Algorithm Steps

• Initialize a list with the first three prime numbers → 2, 3, 5
• Use a loop to generate numbers using the formulas 6k - 1 and 6k + 1 up to n.
• Check if each generated number is prime using a helper function.
• Store all valid prime numbers in a list and print them.

Code Sample (6k ± 1 Optimized Method)

import java.util.ArrayList;

public class PrimeNumber6kMethod {
    public static void main(String[] args) {
        int n = 100; // Upper limit to find primes up to 100
        ArrayList<Integer> primes = new ArrayList<>();

        // Step 1: Add the first three prime numbers explicitly
        if (n >= 2) primes.add(2);
        if (n >= 3) primes.add(3);
        if (n >= 5) primes.add(5);

        // Step 2: Generate numbers using 6k ± 1 pattern and check for primality
        for (int k = 1; 6 * k - 1 <= n || 6 * k + 1 <= n; k++) {
            int num1 = 6 * k - 1; // 6k - 1
            int num2 = 6 * k + 1; // 6k + 1

            // Check if num1 is prime and within the limit
            if (num1 <= n && isPrime(num1)) {
                primes.add(num1);
            }

            // Check if num2 is prime and within the limit
            if (num2 <= n && isPrime(num2)) {
                primes.add(num2);
            }
        }

        // Step 3: Print the prime numbers in a readable format
        System.out.println("Prime numbers from 1 to " + n + ":");
        for (int prime : primes) {
            System.out.print(prime + " ");
        }
    }

    // Helper method to check if a number is prime
    public static boolean isPrime(int num) {
        if (num <= 1) return false; // 0 and 1 are not prime
        if (num <= 3) return true; // 2 and 3 are prime numbers

        // Eliminate even numbers and multiples of 3
        if (num % 2 == 0 || num % 3 == 0) return false;

        // Check divisibility up to the square root of num
        for (int i = 5; i * i <= num; i += 6) {
            if (num % i == 0 || num % (i + 2) == 0) return false;
        }

        return true;
    }
}

Code Explanation

• The primes list stores all valid prime numbers.
• Explicitly adds 2, 3, and 5 before entering the loop since they don’t follow the 6k ± 1 pattern.
• Loop generates numbers using 6k - 1 and 6k + 1 formulas up to n.
• Each number is checked for primality using isPrime().
• isPrime() first eliminates even numbers and multiples of 3, then uses the square root method to check further divisibility.
• Primes are printed in a properly formatted sequence.

Output:

Prime numbers from 1 to 100:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

• The program correctly prints all prime numbers from 1 to 100.
• Numbers like 4, 6, 8, 9, 10 are automatically skipped because they are not in the 6k ± 1 pattern.
• Composite numbers generated by 6k ± 1 (like 25, 35, 49) are correctly removed via isPrime().
• Output is clean and readable, making verification easy.

Time Complexity Analysis

• Filtering numbers using 6k ± 1 removes unnecessary checks, improving efficiency.
• The isPrime() function runs in O(√n) due to the square root method.
• Overall, the method runs in O(√n) per checked number, making it faster than naive trial division but slower than sieve-based approaches.

When to Use the 6k ± 1 Prime Number Method?

• When you need an optimized method that skips unnecessary checks.
• When you’re working with n in the range of thousands to millions (but not extreme values).
• For competitive programming where small optimizations matter.

4. How to Print Prime Numbers from 1 to 100 Using the Arithmetic Prime Number Method in Java?

The arithmetic method for finding prime numbers refers to any approach that applies mathematical patterns to efficiently determine primes while reducing unnecessary checks. Unlike brute-force methods that check every number one by one, arithmetic-based techniques use number properties to filter out composites early.

Several arithmetic methods exist, including:

• 6k ± 1 Method: Eliminates multiples of 2 and 3 before checking for primality.
• Sieve of Eratosthenes: Uses a precomputed list to mark non-primes, making future checks faster.
• Wheel Factorization: Expands on the 6k ± 1 method by skipping multiples of more primes (e.g., 2, 3, and 5).

You have already explored the 6k ± 1 method. This section will focus on the simplest arithmetic-based method: the Sieve of Eratosthenes, which efficiently finds all prime numbers from 1 to 100.

Algorithm Steps (Sieve of Eratosthenes)

• Create a boolean array isPrime[] of size n+1 and initialize all values to true (assuming all numbers are prime).
• Manually mark 0 and 1 as non-prime (since neither are prime numbers).
• Start from 2 (the first prime) and mark all its multiples (4, 6, 8, …) as non-prime.
• Move to the next unmarked number, mark its multiples, and continue.
• Stop when the square of the current number exceeds n because any larger composite number would have been marked earlier.
• Print all numbers that remain marked as true, as these are prime numbers.

Code Sample (Sieve of Eratosthenes - Arithmetic Prime Number Method)

import java.util.Arrays;

public class PrimeNumberArithmeticMethod {
    public static void main(String[] args) {
        int n = 100; // Upper limit
        boolean[] isPrime = new boolean[n + 1];

        // Step 1: Assume all numbers are prime initially
        Arrays.fill(isPrime, true);

        // Step 2: 0 and 1 are not prime numbers
        isPrime[0] = false;
        isPrime[1] = false;

        // Step 3: Start marking multiples of primes
        for (int p = 2; p * p <= n; p++) {
            if (isPrime[p]) { // If p is prime, mark its multiples
                for (int multiple = p * p; multiple <= n; multiple += p) {
                    isPrime[multiple] = false;
                }
            }
        }

        // Step 4: Print all prime numbers
        System.out.println("Prime numbers from 1 to " + n + ":");
        for (int i = 2; i <= n; i++) {
            if (isPrime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

Code Explanation

• A boolean array isPrime[] is initialized, assuming all numbers are prime.
• 0 and 1 are manually marked as false since they are not prime.
• A loop starts at 2, marking all multiples of 2 as composite (e.g., 4, 6, 8…).
• The process repeats for the next smallest unmarked number (3, 5, etc.), marking their multiples as non-prime.
• Numbers that remain true in isPrime[] are printed as prime numbers.

Output:

Prime numbers from 1 to 100:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

• The program correctly prints all prime numbers between 1 and 100.
• Non-prime numbers were efficiently removed using the arithmetic-based sieve method without individually checking each one.
• Larger primes are found quickly because most non-primes were eliminated early in the marking process.

Time Complexity Analysis

• Sieve of Eratosthenes runs in O(n log log n) time, which is much faster than O(n√n) trial division methods.
• Precomputed prime lists can be used for multiple queries, making it highly efficient.
• Space complexity is O(n) since it requires an array of size n.

When to Use the Arithmetic (Sieve) Prime Number Method?

• When you need to generate multiple prime numbers quickly.
• For situations where precomputed prime lists improve performance.
• In coding challenges or competitive programming where efficiency matters.
• When n is large, making trial division methods inefficient.

5. How to Print Prime Numbers from 1 to 100 Using the Wheel Factorization Prime Number Method in Java?

The Wheel Factorization method is an advanced arithmetic approach to efficiently filter prime numbers by eliminating multiples of small prime numbers before performing any divisibility checks. 

This technique is an extension of the 6k ± 1 method, skipping not just multiples of 2 and 3, but also higher prime factors like 5, 7, and beyond, making prime detection even faster.

Why Use the Wheel Factorization Method?

• Reduces unnecessary prime checks by filtering out multiples of small primes (e.g., 2, 3, 5, 7).
• Optimizes the range of numbers to check, making it more efficient than trial division or 6k ± 1 filtering.
• Best suited for large n, where traditional methods start to slow down.

The basic idea behind wheel factorization is that primes tend to be spaced in predictable patterns after eliminating small prime multiples. The larger the wheel, the more numbers you can skip and the fewer checks you need to perform.

What Is a Prime Wheel?

• A prime wheel is a cycle of numbers that eliminates multiples of small prime numbers early.
• The simplest wheel eliminates numbers divisible by 2 and 3. This is the 6k ± 1 method.
• A larger wheel eliminates multiples of 2, 3, and 5. This is called a 30k ± {1, 7, 11, 13, 17, 19, 23, 29} wheel.
• The next level eliminates multiples of 2, 3, 5, and 7, which further reduces unnecessary checks.

Each larger wheel skips more numbers and ensures we only check the smallest set of potential primes.

Algorithm Steps (Wheel Factorization for Prime Numbers)

1. Start by marking all numbers as prime in an array.
2. Eliminate numbers that are multiples of small primes (2, 3, 5, 7, etc.) before checking divisibility.
3. Generate numbers using the wheel cycle instead of iterating over all numbers.
4. Apply the square root optimization to further reduce checks.

Code Sample (Wheel Factorization for Prime Numbers in Java)

import java.util.ArrayList;
import java.util.Arrays;

public class PrimeNumberWheelFactorization {
    public static void main(String[] args) {
        int n = 100; // Upper limit
        ArrayList<Integer> primes = new ArrayList<>();

        // Step 1: Manually add the first few small primes
        if (n >= 2) primes.add(2);
        if (n >= 3) primes.add(3);
        if (n >= 5) primes.add(5);
        if (n >= 7) primes.add(7);

        // Step 2: Create a boolean array for prime markings
        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);

        // Step 3: Eliminate known small prime multiples
        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int multiple = i * i; multiple <= n; multiple += i) {
                    isPrime[multiple] = false;
                }
            }
        }

        // Step 4: Generate potential prime candidates using the 30k wheel pattern
        int[] wheel = {1, 7, 11, 13, 17, 19, 23, 29}; // Numbers not divisible by 2, 3, or 5
        for (int k = 1; 30 * k <= n; k++) {
            for (int offset : wheel) {
                int candidate = 30 * k + offset;
                if (candidate <= n && isPrime[candidate]) {
                    primes.add(candidate);
                }
            }
        }

        // Step 5: Print the prime numbers in a readable format
        System.out.println("Prime numbers from 1 to " + n + ":");
        for (int prime : primes) {
            System.out.print(prime + " ");
        }
    }
}

Code Explanation

• First, manually add 2, 3, 5, 7 to the prime list since the wheel pattern does not cover these.
• A boolean array isPrime[] is created, assuming all numbers are prime initially.
• Multiples of known primes are eliminated using a sieve-like approach.
• A 30k ± {1, 7, 11, 13, 17, 19, 23, 29} wheel is applied to generate prime candidates efficiently.
• Only numbers within this cycle are checked, reducing unnecessary calculations.
• Prime numbers are stored and printed in a clean, readable format.

Output:

Prime numbers from 1 to 100:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

• All prime numbers between 1 and 100 are correctly identified.
• Multiples of 2, 3, 5, and 7 are filtered early, reducing unnecessary divisibility checks.
• The prime wheel ensures that fewer numbers are tested, making the algorithm significantly faster.

Time Complexity Analysis

• Wheel factorization reduces unnecessary checks, improving efficiency.
• The initial prime marking runs in O(n log log n) time (same as the Sieve of Eratosthenes).
• The final prime check runs in O(√n) per number, making it more efficient than trial division.
• Overall, the approach runs in O(n / log log n) for prime number generation.

When to Use the Wheel Factorization Prime Number Method?

• When you need a fast and optimized method for large values of n.
• When simple trial division or 6k ± 1 filtering is too slow.
• For competitive programming and large-scale computations where efficiency is key.
• When generating prime numbers in bulk for cryptographic applications.

6. How to Print Numbers from 1 to 100 Using the Count Prime Number Program in Java? 

Printing prime numbers from 1 to 100 in Java using the count method is a straightforward way to understand prime number detection. 

• The count method involves counting the number of divisors for each number. 
• If the count is exactly two (1 and the number itself), it is a prime number. 

This method offers a straightforward way to check for primes, although it’s not as efficient as the square root or 6k ± 1 methods.

Explanation

In this method, you count how many numbers divide into the current number. If only two divisors are found (1 and the number itself), the number is prime.

Algorithm Steps

• Loop through numbers from 2 to 100.
• For each number, count how many times it can be divided evenly by another number.
• If the count is exactly 2, the number is prime.

Code Sample (Count Prime Method in Java):

public class PrimeNumber {
    public static void main(String[] args) {
        for (int num = 2; num <= 100; num++) {
            int count = 0;
            for (int i = 1; i <= num; i++) {
                if (num % i == 0) {
                    count++;
                }
            }
            if (count == 2) {
                System.out.println(num);
            }
        }
    }
}

Code Explanation:

• The loop runs from 2 to 100, checking each number.
• A count variable is initialized to 0 before checking each number.
• A nested loop runs from 1 to num, checking for divisibility.
• Each time num is divisible by i, count is incremented.
• If count == 2, the number is printed as prime.

Output:

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

• Only numbers with exactly two divisors (1 and the number itself) are printed.
• Composite numbers (e.g., 4, 6, 8, 9) have more than two divisors and are skipped.
• Primes are displayed in a single line for readability.

Time Complexity Analysis

• The inner loop runs from 1 to num for each number, making this method O(n²) in the worst case.
• Checking every number up to n for divisibility is inefficient, especially for larger numbers.
• Slower than the square root method (O(√n)) and much slower than the Sieve of Eratosthenes (O(n log log n)).

When to Use the Count Prime Number Method?

• When performance is not a concern, such as small-range prime checks.
• For educational purposes, before introducing optimized approaches.
• When simplicity is more important than efficiency.

How to Find a Prime Number in Java Within a Range? 

Finding prime numbers in a given range is an essential task in many programming problems, especially in fields like cryptography, number theory, and data science.

It involves iterating through the numbers in a given range and checking each one to see if it meets the criteria of being a prime. 

This process generally requires checking divisibility from 2 up to the number minus one.

Let’s dive into different methods you can use to find prime numbers in Java and see how you can implement each one with simple loops or even recursion.

Method 1: How to Find a Prime Number Using For Loop?

The for-loop method is one of the most straightforward ways to check whether a number is prime within a given range. You iterate over each number in the range and check whether it is divisible by any smaller numbers. 

If it is not divisible by any number other than 1 and itself, it is prime.

Overview of the Method

This method uses a for loop to iterate through all numbers in the specified range. 

• For each number, you check if it is divisible by any number from 2 to that number minus one. 
• If no divisors are found, the number is considered prime.

Steps Followed

• Loop through all numbers in the given range.
• For each number, check divisibility from 2 to the number minus 1.
• If the number is not divisible by any of these, it is prime.
• Print the prime numbers.

Example Code

public class PrimeInRange {
    public static void main(String[] args) {
        int start = 10; // Start of range
        int end = 50;  // End of range

        System.out.println("Prime numbers between " + start + " and " + end + " are:");
        for (int num = start; num <= end; num++) {
            boolean isPrime = true;
            for (int i = 2; i < num; i++) {
                if (num % i == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime && num > 1) {
                System.out.println(num);
            }
        }
    }
}

Code Explanation

• We defined the range from 10 to 50.
• For each number in that range, we checked divisibility starting from 2 to the number minus 1.
• If the number is divisible by any other number, it’s marked as not prime. If it passes the divisibility test, it is considered prime.

Benefits

• Easy to understand and implement.
• Works well for small ranges.

Drawbacks

It is inefficient for large numbers or ranges because it checks divisibility up to n−1, which becomes slow as the numbers grow larger.

Also Read: For Loop in Java

Method 2: How to Find Prime Numbers Using a While Loop?

The while loop method works similarly to the for loop method but uses a while loop instead. This method is especially useful when you want more control over the loop conditions or don’t know the number of iterations in advance.

Overview of the Method

This approach uses a while loop to iterate through numbers in the specified range, checking each one for primality. The logic remains the same as that of the for-loop method, but here, the iteration and checks are performed using a while loop.

Steps Followed

• Start with the given range.
• Use a while loop to iterate through each number.
• For each number, check divisibility from 2 up to the square root of the number.
• If no divisors are found, the number is prime and is printed.

Example Code

public class PrimeInRangeWhile {
    public static void main(String[] args) {
        int start = 10; // Start of range
        int end = 50;  // End of range
System.out.println("Prime numbers between " + start + " and " + end + " are:");
        int num = start;
        while (num <= end) {
            boolean isPrime = true;
            int i = 2;
            while (i <= Math.sqrt(num)) {
                if (num % i == 0) {
                    isPrime = false;
                    break;
                }
                i++;
            }
            if (isPrime && num > 1) {
                System.out.println(num);
            }
            num++;
        }
    }
}

Code Explanation

• The while loop checks each number in the given range.
• For efficiency, use an inner while loop to check divisibility up to the square root of the current number.
• If a number has no divisors, it's identified as a prime.

Benefits

• Similar to the for loop but offers more flexibility with iteration.
• More control over the conditions inside the loop.

Drawback

It can still be inefficient for larger ranges since you check divisibility for each number.

Also Read: Java Do While Loop With Examples

Method 3: How to Find Prime Numbers Using Recursion?

Recursion is a more advanced technique for checking whether a number is prime. In recursion, a function calls itself to break down the problem into smaller, simpler subproblems. While recursion can be elegant, it might not always be the most efficient approach, especially for large ranges.

Overview of the Method

In this method, recursion checks whether a number is divisible by any number starting from 2, up to its square root. 

The base case is simple: 

• If the number has been checked against all divisors up to the square root, the function returns true (if no divisors are found) or false (if a divisor is found). 
• The recursive step involves checking divisibility and calling the function again for the next divisor.

While this approach offers an elegant solution, its major drawback is the overhead of recursive function calls, especially for large numbers. But for smaller ranges, it’s a clean and efficient way to demonstrate recursion.

Steps Followed

• Base Case: If the divisor exceeds the square root of the number and no divisors have been found, return true.
• Recursive Step: Start checking divisibility from 2, and for each divisor, call the function again to check the next divisor.
• Termination: If any divisor is found, return false. If the base case is met without finding any divisors, return true.

Example Code

public class PrimeRecursion {
    public static void main(String[] args) {
        int number = 29;  // Example number
        if (isPrime(number, 2)) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }

    public static boolean isPrime(int number, int divisor) {
        // Base case: If divisor exceeds square root of number, it is prime
        if (divisor > Math.sqrt(number)) {
            return true;
        }
        // If number is divisible by any divisor, it is not prime
        if (number % divisor == 0) {
            return false;
        }
        // Recursive call with the next divisor
        return isPrime(number, divisor + 1);
    }
}

Output:

29 is a prime number.

Why Does It Work?

• Base Case: If the divisor exceeds the square root of the number, it returns true, meaning no factors were found, and the number is prime.
• Recursive Step: The function checks if the number is divisible by the current divisor and then calls itself with the next divisor.

Elegance and Efficiency

Recursion's elegance lies in its simplicity:

• It breaks the problem down into smaller checks without needing complex loops.
• While recursive functions are clean and easy to read. They can be inefficient for larger numbers due to the overhead of multiple function calls. 

Also Read: Recursion in Data Structure: How Does it Work, Types & When Used

How to Check Very Large Prime Numbers with Java’s BigInteger Method?

When numbers exceed the range of standard data types, you can rely on BigInteger. Java provides isProbablePrime(int certainty) to handle huge values. It uses advanced algorithms like Miller-Rabin behind the scenes.

Key Steps to Follow

• Create a BigInteger instance from a string or another big representation.
• Call isProbablePrime(certainty). If it returns true, the number is prime with a high probability. If it returns false, the number is definitely composite.

Code Example

import java.math.BigInteger;

public class PrimeCheckBigInteger {
    public static void main(String[] args) {
        // Example 11-digit prime
        BigInteger bigNum = new BigInteger("32416190071");
        if (bigNum.isProbablePrime(10)) {
            System.out.println(bigNum + " is probably prime.");
        } else {
            System.out.println(bigNum + " is not prime.");
        }
    }
}

Time Complexity Analysis
A probabilistic test like Miller-Rabin performs quickly even for extremely large numbers. It rarely misidentifies composites as primes when the certainty level is sufficient.

When to Use the BigInteger Method?

• Cryptography or other applications involving very large integers.
• Mathematical research or tasks involving prime checks for numbers that exceed long range.

How Can You Print a Prime Series in Java Using Different Methods?

A prime series in Java refers to a sequence of prime numbers printed or stored using different approaches. You can generate a prime series using methods like trial division, square root optimization, the Sieve of Eratosthenes, or 6k ± 1 filtering.

Depending on your requirements, you might need to follow the steps listed below:

1. Print all prime numbers within a given range.
2. Print the first N prime numbers.
3. Store prime numbers in a list or data structure for further processing.

Each of these tasks can be achieved using different prime-checking methods. 

Below are various ways to generate a prime series in Java for a specific range.

How to Print a Prime Series in Java for a Given Range [A, B]?

If you need to print all prime numbers between two given numbers, here’s what you need to do:

• Loop through numbers from A to B.
• Use a prime-checking function (isPrime(n)) to verify if a number is prime.
• Print the number if it is prime.

Code Example (Prime Series in a Range)

public class PrimeSeriesInRange {
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        if (n == 2) {
            return true;
        }
        if (n % 2 == 0) {
            return false;
        }
        for (int i = 3; i <= Math.sqrt(n); i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int start = 10;
        int end = 30;
        System.out.println("Prime series in Java from " + start + " to " + end + ":");
        for (int num = start; num <= end; num++) {
            if (isPrime(num)) {
                System.out.print(num + " ");
            }
        }
    }
}

Output:

Prime series in Java from 10 to 30:
11 13 17 19 23 29

How to Print the First N Prime Numbers as a Prime Series in Java?

Sometimes, you may need the first N prime numbers rather than a range-based series. 

Here’s what you need to do in this method:

• Start from 2 (the first prime) and check numbers one by one.
• Maintain a count of how many primes have been found.
• Stop when N prime numbers have been printed.

Code Example (Print First N Primes)

public class PrimeSeriesFirstN {
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        if (n == 2) {
            return true;
        }
        if (n % 2 == 0) {
            return false;
        }
        for (int i = 3; i <= Math.sqrt(n); i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int N = 10; // Print first 10 prime numbers
        int count = 0;
        int num = 2;
        
        System.out.println("Prime series in Java for the first " + N + " prime numbers:");
        while (count < N) {
            if (isPrime(num)) {
                System.out.print(num + " ");
                count++;
            }
            num++;
        }
    }
}

Output:

Prime series in Java for the first 10 prime numbers:
2 3 5 7 11 13 17 19 23 29

How to Store a Prime Series in Java Using a Data Structure?

If you need to store prime numbers for later use, here’s what you can do:

• Use an ArrayList<Integer> to collect prime numbers.
• Print them when needed.

Code Example (Storing a Prime Series in an ArrayList)

import java.util.ArrayList;

public class PrimeSeriesStorage {
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        if (n == 2) {
            return true;
        }
        if (n % 2 == 0) {
            return false;
        }
        for (int i = 3; i <= Math.sqrt(n); i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int n = 50; // Generate prime series up to 50
        ArrayList<Integer> primes = new ArrayList<>();

        for (int i = 2; i <= n; i++) {
            if (isPrime(i)) {
                primes.add(i);
            }
        }

        System.out.println("Stored prime series in Java up to " + n + ": " + primes);
    }
}

Output:

Stored prime series in Java up to 50: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Also Read: Java Program to Print Prime Numbers in a Given Range

Why are Prime Numbers Important in Programming?

Prime numbers aren’t just mathematical curiosities – they have practical uses in computing and everyday technology. 

Here are some real-world applications of prime numbers that show why understanding primes (and programming them) is so important:

• Cryptography and Security: Ever bought something online or sent a secure message? Prime numbers made it possible. 

Primes form the backbone of public-key encryption algorithms like RSA​. The security of RSA comes from the fact that while it’s easy to multiply two large primes, it’s insanely hard to factor the result back into primes. This one-way difficulty keeps your data safe. 

Primes also power digital signatures – ensuring documents or software haven’t been tampered with by using large prime-based keys​

• Hashing Algorithms: Many hashing and data structures use primes to reduce collisions. For instance, hash tables often use a prime number as the table size or in hash functions to evenly distribute keys​. Primes help ensure that data is spread out more uniformly, which improves lookup performance.
• Random Number Generation: Some pseudorandom number generators use prime numbers to achieve better distribution of values​. Primes can help in creating cycles of maximum length when generating sequences, making the numbers feel random longer. 

They’re also used in algorithms like the Blum Blum Shub generator in cryptography.

• Error Detection: Methods like cyclic redundancy checks (CRCs) and checksums sometimes involve primes​. For example, certain error-detecting codes use prime moduli to catch data corruption. The idea is that using a prime base can make it less likely for structured errors to slip through undetected.
• Other Areas: Primes pop up in network routing algorithms, patterns in nature, and even music theory. 

In computer science, they’re used in algorithms for randomized algorithms and primality testing – which is literally what we’re discussing today. Primes also intrigue mathematicians and programmers in computational number theory and competitive programming challenges.

Also Read: Public Key Cryptography Beginner’s Guide: How Does it Work?

Ready to begin your Java development journey? Explore upGrad’s Core Java Basics free course to get a solid foundation in programming and start learning today.

How Should You Practice Prime Number Programming in Java?

Hands-on coding cements these concepts in your mind. 

You may try the following ideas:

• Compare Different Methods: Pick a range, say up to 1,00,000, and measure how fast each method checks every number in that range. Observe how brute force struggles while the square root method and 6k ± 1 do better.
• Implement a Segmented Sieve: If you want to generate primes in extremely large ranges without huge memory usage, the segmented sieve is an advanced extension of the classic sieve.
• Modify Examples: Change the code to handle edge cases like negative inputs or zero. Confirm that you return false for them.
• Combine Approaches: You could sieve up to a certain threshold and then use a primality test beyond that threshold. This combination sometimes benefits larger ranges.

When you perform these exercises, pay attention to performance, clarity, and correctness. Writing tests for each method (including random test data) goes a long way toward boosting your confidence in their reliability.

How Can upGrad Help You Build a Career in Programming?

Building a career in programming is no longer just about writing lines of code — it’s about mastering the real-world skills that companies demand. upGrad ensures that you learn and apply what you learn to solve real challenges. 

Here’s how upGrad helps you build the expertise needed to succeed in the world of coding:

• Hands-On Learning: Build real-world projects like face detection systems for practical, applied experience.
• Personalized Mentorship: Get one-on-one guidance to master complex topics and receive career advice.
• Industry-Relevant Skills: Focus on in-demand technologies and tools, like Python and OpenCV, to stay ahead.

Here are a few upGrad coding and programming courses that will help you launch your development career: 

• Java Object-oriented Programming Free Certificate Course
• JavaScript Basics from Scratch Free Certificate Course
• Master of Design in User Experience
• Best Full Stack Developer Bootcamp 2024

Ready to kickstart your development career? Book a free career counseling session with upGrad today and start building the future you’ve always dreamed of.

Similar Blogs and Tutorials You Might Find Useful:

• Prime Number Program in C: Step-by-Step Guide
• Perfect Number in Python: Unraveling the Secrets
• Perfect Number Program In Python
• C Program to Check Whether a Number Is Prime
• 7 Different Methods to Check Prime Numbers in Python
• Mastering Number Pattern Programs in Java

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software