DSA Tutorials Practice Sheet DSA Problems
Java Java Programs
PythonSoon
CSoon
C++Soon
JavaScriptSoon
Computer NetworksSoon
Operating SystemsSoon
OOPsSoon
DBMSSoon
System DesignSoon
Spring BootSoon
DockerSoon
KubernetesSoon
KafkaSoon
Compiler
Jobs
About

Java Tutorial

🔍

Java Introduction What is Java?History & Features JDK vs JRE vs JVM How Java Works Install Java & Setup First Java Program Java vs Other Languages

Syntax & Structure Java Keywords & Reserved Words Naming Conventions Data Types Variables Type Casting Operators Increment & Decrement Operators Escape Sequences Math Class User Input (Scanner)Command Line Arguments Wrapper Classes Autoboxing & Unboxing final Keyword Comments

if Statement if-else Statement else-if Ladder Nested if switch Statement for Loop while Loop do-while Loop for-each Loop Nested Loops break Statement continue Statement return Statement

Methods Overview Parameters & Return Types Method Overloading Recursion Variable Arguments (varargs)Pass by Value vs Pass by Reference

Arrays Overview Multi-dimensional Arrays Arrays class Passing Arrays to Methods

String Overview String Methods String Comparison equals() vs ==String Pool StringBuilder StringBuffer String vs StringBuilder vs StringBuffer Immutable Strings String Formatting String Class Deep Dive

Packages in Java Creating Custom Packages import Statement Access Modifiers Deep Dive public Access Modifier private Access Modifier protected Access Modifier default Access Modifier

Inner Classes Static Nested Class Anonymous Classes Enums Records (Java 16+)Sealed Classes (Java 17+)Immutable Classes Object Cloning Shallow vs Deep Copy Annotations Built-in Annotations Custom Annotations Reflection API

What is Exception Handling?Exception vs Error Exception Hierarchy Checked vs Unchecked Exceptions Common Java Exceptions try-catch Multi-catch finally Block try-with-resources throw Keyword throws Keyword throw vs throws Custom Exceptions Exception Propagation

Generics Overview Why Generics?Generic Classes Generic Interfaces Generic Methods Bounded Type Parameters Wildcards (?)Upper-Bounded Wildcards (? extends)Lower-Bounded Wildcards (? super)Generics in the Collections Framework Type Inference (Diamond Operator)Type Erasure What Generics Cannot Do

Lambda Expressions Functional Interfaces Method References Predicate Function Consumer Supplier Optional

Streams Overview filter()map()forEach()reduce()collect()sorted()distinct()limit()skip()Collectors & groupingBy()Parallel Streams Stream vs Parallel Stream

Introduction to Date & Time API LocalDate LocalTime LocalDateTime ZonedDateTime Period Duration DateTimeFormatter Legacy Date vs New API

Java 8 Key Features Java 11 Features Java 17 Features Java 21 Features var (Local Type Inference)Text Blocks Pattern Matching Switch Expressions Virtual Threads (Java 21)

File & Path Overview Reading Files Writing Files BufferedReader & Writer NIO.2 (java.nio)Serialization Externalization Serialization vs Externalization

Threads Overview Runnable & Callable Thread Lifecycle Synchronization volatile Keyword Race Conditions Deadlock Livelock Starvation wait, notify & notifyAll Lock & ReentrantLock Semaphore Atomic Variables ConcurrentHashMap Executor Framework CompletableFuture ForkJoinPool

JVM Architecture Stack Memory Heap Memory Stack vs Heap Memory Garbage Collection Metaspace vs PermGen ClassLoader JIT Compiler

Java Programs›Control Flow›Check Prime Number

Check Prime Number in Java

intermediate· Control Flow · Math

Problem

A prime number is a number greater than 1 that has exactly two factors: 1 and itself.

Given an integer, determine whether it is a prime number.

Input

29

Output

29 is prime: true

Java Program

Java

public class PrimeCheck {
    public static void main(String[] args) {
        int n = 29;
        boolean isPrime = n > 1; // numbers 1 and below are never prime
        // Only check divisors up to sqrt(n) — any factor beyond that has a matching smaller one
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                isPrime = false;
                break; // found a divisor, no need to keep checking
            }
        }
        System.out.println(n + " is prime: " + isPrime);
    }
}

Output

29 is prime: true

Core Logic

You only need to test divisors up to the square root of the number — anything larger would already have a smaller matching factor.

How It Works

1isPrime starts as n > 1, since numbers ≤ 1 are never prime.
2The loop runs i from 2 upward, but only while i * i <= n — an integer-only stand-in for checking up to √n.
3At each i, n % i == 0 checks whether i divides n evenly.
4If a divisor is found, isPrime is set to false and break exits the loop immediately.
5If the loop finishes with no divisor found, n is confirmed prime.

For n = 29, the loop checks i = 2 through 5 (since 6 * 6 = 36 > 29), finds no divisor, and reports 29 as prime.

💡

Key Point: Using i * i <= n instead of Math.sqrt(n) avoids floating-point comparison and keeps the bound check a cheap integer multiply.

Key Concepts

modulo operatorloop with breaksquare-root bound

Approach 2: BigInteger.isProbablePrime()

Java

import java.math.BigInteger;

public class PrimeCheckBigInteger {
    public static void main(String[] args) {
        int n = 29;
        // isProbablePrime() runs a Miller-Rabin test with a certainty of 100
        boolean isPrime = BigInteger.valueOf(n).isProbablePrime(100);
        System.out.println(n + " is prime: " + isPrime);
    }
}

Output

29 is prime: true

Core Logic

Java's BigInteger class already knows how to test primality — no need to write the divisor loop yourself.

How It Works

1BigInteger.valueOf(n) wraps the int into a BigInteger.
2.isProbablePrime(100) runs a probabilistic primality test (Miller–Rabin) with a certainty parameter of 100.
3The certainty parameter controls the probability of a false positive — higher values make a wrong answer astronomically unlikely.

BigInteger.valueOf(29).isProbablePrime(100) returns true.

💡

Key Point: 'Probable' isn't a red flag here — with a certainty of 100, the chance of a composite number being misreported as prime is far smaller than the chance of a hardware error, and this scales to numbers far too large for a trial-division loop to check quickly.

Key Concepts

BigIntegerisProbablePrime()Miller–Rabin

Related Programs

Control Flowbeginner

Stringsintermediate

Stringsbeginner

Check Palindrome String

Stringsbeginner

Count Characters in a String

Stringsbeginner

Reverse a String