Java Coding Questions for Freshers in 2026:

Sep 23, 2026

If you are preparing for a Java developer job as a fresher in 2026, one of the most important parts of your preparation is coding practice.

Knowing Java theory is useful, but technical interviews and coding assessments often require you to write, understand, debug or explain actual code.

A fresher may be asked to:

Write a Java program to reverse a string
Find duplicate elements in an array
Check whether a number is prime
Find the second-largest number
Count characters in a string
Explain OOP concepts with code
Use Java Collections
Solve an array or string problem
Write SQL queries
Explain JOINs
Work with Java 8 Stream API
Create a basic REST API
Explain a Spring Boot application
Debug an incorrect program
Discuss time and space complexity

This makes Java coding questions for freshers an important search and preparation topic for students targeting Java developer, backend developer, Full Stack Java Developer and software development roles.

This guide provides a structured collection of Java coding questions, Java programs, OOP examples, collections programs, Java 8 examples, DSA problems, SQL queries, REST API examples and interview-oriented coding practice.

The goal is not to memorize 40 programs.

The goal is to understand the patterns behind them.

Why Java Coding Practice Matters for Freshers

Many freshers make the same mistake.

They spend several weeks watching Java tutorials but spend very little time actually writing Java programs.

Programming works differently from theoretical subjects.

You need repeated practice to become comfortable with:

Syntax
Logic
Conditions
Loops
Arrays
Strings
Methods
Classes
Objects
Collections
Exception handling
Problem solving
Debugging
Complexity analysis

For example, knowing what a for loop is does not necessarily mean you can solve an array problem using one.

Similarly, knowing that HashSet does not allow duplicate elements is different from knowing when and why to use it in a coding problem.

That is why a strong Java coding practice strategy for freshers should move from simple programs to problem-solving patterns.

What Java Coding Interviews Actually Test

A coding question is rarely only about whether your code produces the correct output.

Interviewers may also look at:

Area	What You Should Demonstrate
Syntax	Correct Java syntax
Logic	Clear problem-solving approach
Data structures	Appropriate data structure selection
Efficiency	Reasonable time and space complexity
Edge cases	Handling unusual inputs
Readability	Understandable code
Debugging	Ability to identify errors
Explanation	Ability to explain your approach

For example, if you solve duplicate detection using nested loops, your answer may work.

But if you understand how a HashSet can reduce unnecessary comparisons, you can discuss the trade-off between time and memory.

That is the difference between simply writing code and thinking like a developer.

Java Coding Preparation Roadmap

A useful progression is:

Java Syntax
     ↓
Basic Programs
     ↓
Strings & Arrays
     ↓
OOP
     ↓
Collections
     ↓
Java 8+
     ↓
DSA
     ↓
SQL
     ↓
REST APIs
     ↓
Spring Boot
     ↓
Project Debugging
     ↓
Technical Interview

Java Syntax
     ↓
Basic Programs
     ↓
Strings & Arrays
     ↓
OOP
     ↓
Collections
     ↓
Java 8+
     ↓
DSA
     ↓
SQL
     ↓
REST APIs
     ↓
Spring Boot
     ↓
Project Debugging
     ↓
Technical Interview

Java Syntax
     ↓
Basic Programs
     ↓
Strings & Arrays
     ↓
OOP
     ↓
Collections
     ↓
Java 8+
     ↓
DSA
     ↓
SQL
     ↓
REST APIs
     ↓
Spring Boot
     ↓
Project Debugging
     ↓
Technical Interview

Do not jump directly from basic Java syntax to advanced frameworks.

A strong foundation makes the later technologies easier to understand.

Java Program 1: Reverse a String

One of the most common beginner Java coding questions is reversing a string.

public class ReverseString {

    public static void main(String[] args) {

        String str = "VibrantMinds";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse = reverse + str.charAt(i);
        }

        System.out.println(reverse);
    }
}

public class ReverseString {

    public static void main(String[] args) {

        String str = "VibrantMinds";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse = reverse + str.charAt(i);
        }

        System.out.println(reverse);
    }
}

public class ReverseString {

    public static void main(String[] args) {

        String str = "VibrantMinds";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse = reverse + str.charAt(i);
        }

        System.out.println(reverse);
    }
}

Output:

sdniMtnarbiV

sdniMtnarbiV

sdniMtnarbiV

The important concepts are:

String
length()
charAt()
for loop
String concatenation

A common interview follow-up is:

Can you reverse a string using StringBuilder?

String str = "Java";

String result = new StringBuilder(str)
                    .reverse()
                    .toString();

System.out.println(result);

String str = "Java";

String result = new StringBuilder(str)
                    .reverse()
                    .toString();

System.out.println(result);

String str = "Java";

String result = new StringBuilder(str)
                    .reverse()
                    .toString();

System.out.println(result);

This is shorter, but you should understand both approaches.

Java Program 2: Check Whether a Number Is Prime

public class PrimeNumber {

    public static void main(String[] args) {

        int number = 29;
        boolean isPrime = true;

        if (number <= 1) {
            isPrime = false;
        }

        for (int i = 2; i <= number / 2; i++) {

            if (number % i == 0) {
                isPrime = false;
                break;
            }
        }

        if (isPrime) {
            System.out.println("Prime Number");
        } else {
            System.out.println("Not a Prime Number");
        }
    }
}

public class PrimeNumber {

    public static void main(String[] args) {

        int number = 29;
        boolean isPrime = true;

        if (number <= 1) {
            isPrime = false;
        }

        for (int i = 2; i <= number / 2; i++) {

            if (number % i == 0) {
                isPrime = false;
                break;
            }
        }

        if (isPrime) {
            System.out.println("Prime Number");
        } else {
            System.out.println("Not a Prime Number");
        }
    }
}

public class PrimeNumber {

    public static void main(String[] args) {

        int number = 29;
        boolean isPrime = true;

        if (number <= 1) {
            isPrime = false;
        }

        for (int i = 2; i <= number / 2; i++) {

            if (number % i == 0) {
                isPrime = false;
                break;
            }
        }

        if (isPrime) {
            System.out.println("Prime Number");
        } else {
            System.out.println("Not a Prime Number");
        }
    }
}

Interviewers may ask:

Why do we use the % operator?

The modulo operator gives the remainder after division.

If a number has a divisor other than 1 and itself, it is not prime.

Java Program 3: Check Palindrome

A palindrome reads the same forward and backward.

Examples:

madam
level
radar

madam
level
radar

madam
level
radar

Java example:

public class Palindrome {

    public static void main(String[] args) {

        String str = "madam";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse += str.charAt(i);
        }

        if (str.equals(reverse)) {
            System.out.println("Palindrome");
        } else {
            System.out.println("Not a Palindrome");
        }
    }
}

public class Palindrome {

    public static void main(String[] args) {

        String str = "madam";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse += str.charAt(i);
        }

        if (str.equals(reverse)) {
            System.out.println("Palindrome");
        } else {
            System.out.println("Not a Palindrome");
        }
    }
}

public class Palindrome {

    public static void main(String[] args) {

        String str = "madam";
        String reverse = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reverse += str.charAt(i);
        }

        if (str.equals(reverse)) {
            System.out.println("Palindrome");
        } else {
            System.out.println("Not a Palindrome");
        }
    }
}

A better interview discussion would include how to solve the same problem without creating another complete string.

Java Program 4: Find the Largest Number in an Array

public class LargestNumber {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = numbers[0];

        for (int number : numbers) {

            if (number > largest) {
                largest = number;
            }
        }

        System.out.println("Largest: " + largest);
    }
}

public class LargestNumber {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = numbers[0];

        for (int number : numbers) {

            if (number > largest) {
                largest = number;
            }
        }

        System.out.println("Largest: " + largest);
    }
}

public class LargestNumber {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = numbers[0];

        for (int number : numbers) {

            if (number > largest) {
                largest = number;
            }
        }

        System.out.println("Largest: " + largest);
    }
}

Output:

Largest: 89

Largest: 89

Largest: 89

This is a simple example of array traversal.

Java Program 5: Find the Second-Largest Number

This is slightly more challenging.

public class SecondLargest {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = Integer.MIN_VALUE;
        int secondLargest = Integer.MIN_VALUE;

        for (int number : numbers) {

            if (number > largest) {
                secondLargest = largest;
                largest = number;
            }
            else if (number > secondLargest && number != largest) {
                secondLargest = number;
            }
        }

        System.out.println("Second Largest: " + secondLargest);
    }
}

public class SecondLargest {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = Integer.MIN_VALUE;
        int secondLargest = Integer.MIN_VALUE;

        for (int number : numbers) {

            if (number > largest) {
                secondLargest = largest;
                largest = number;
            }
            else if (number > secondLargest && number != largest) {
                secondLargest = number;
            }
        }

        System.out.println("Second Largest: " + secondLargest);
    }
}

public class SecondLargest {

    public static void main(String[] args) {

        int[] numbers = {10, 25, 7, 89, 45};

        int largest = Integer.MIN_VALUE;
        int secondLargest = Integer.MIN_VALUE;

        for (int number : numbers) {

            if (number > largest) {
                secondLargest = largest;
                largest = number;
            }
            else if (number > secondLargest && number != largest) {
                secondLargest = number;
            }
        }

        System.out.println("Second Largest: " + secondLargest);
    }
}

This is a useful question because it tests whether you can maintain multiple variables while traversing an array.

Java Program 6: Count Vowels in a String

public class CountVowels {

    public static void main(String[] args) {

        String str = "Java Developer";
        int count = 0;

        str = str.toLowerCase();

        for (int i = 0; i < str.length(); i++) {

            char ch = str.charAt(i);

            if (ch == 'a' ||
                ch == 'e' ||
                ch == 'i' ||
                ch == 'o' ||
                ch == 'u') {

                count++;
            }
        }

        System.out.println("Vowels: " + count);
    }
}

public class CountVowels {

    public static void main(String[] args) {

        String str = "Java Developer";
        int count = 0;

        str = str.toLowerCase();

        for (int i = 0; i < str.length(); i++) {

            char ch = str.charAt(i);

            if (ch == 'a' ||
                ch == 'e' ||
                ch == 'i' ||
                ch == 'o' ||
                ch == 'u') {

                count++;
            }
        }

        System.out.println("Vowels: " + count);
    }
}

public class CountVowels {

    public static void main(String[] args) {

        String str = "Java Developer";
        int count = 0;

        str = str.toLowerCase();

        for (int i = 0; i < str.length(); i++) {

            char ch = str.charAt(i);

            if (ch == 'a' ||
                ch == 'e' ||
                ch == 'i' ||
                ch == 'o' ||
                ch == 'u') {

                count++;
            }
        }

        System.out.println("Vowels: " + count);
    }
}

This program demonstrates:

String traversal
Character comparison
Conditional statements
Counters

Java Program 7: Count Characters in a String

A HashMap can be useful for frequency counting.

import java.util.HashMap;
import java.util.Map;

public class CharacterFrequency {

    public static void main(String[] args) {

        String str = "java";

        Map<Character, Integer> frequency =
                new HashMap<>();

        for (char ch : str.toCharArray()) {

            frequency.put(
                ch,
                frequency.getOrDefault(ch, 0) + 1
            );
        }

        System.out.println(frequency);
    }
}

import java.util.HashMap;
import java.util.Map;

public class CharacterFrequency {

    public static void main(String[] args) {

        String str = "java";

        Map<Character, Integer> frequency =
                new HashMap<>();

        for (char ch : str.toCharArray()) {

            frequency.put(
                ch,
                frequency.getOrDefault(ch, 0) + 1
            );
        }

        System.out.println(frequency);
    }
}

import java.util.HashMap;
import java.util.Map;

public class CharacterFrequency {

    public static void main(String[] args) {

        String str = "java";

        Map<Character, Integer> frequency =
                new HashMap<>();

        for (char ch : str.toCharArray()) {

            frequency.put(
                ch,
                frequency.getOrDefault(ch, 0) + 1
            );
        }

        System.out.println(frequency);
    }
}

Possible output:

{a=2, v=1, j=1}

{a=2, v=1, j=1}

{a=2, v=1, j=1}

This introduces an important interview pattern:

Frequency counting using a HashMap.

The same pattern can be applied to:

Characters
Numbers
Words
IDs
Product codes

Java Program 8: Find Duplicate Elements

import java.util.HashSet;
import java.util.Set;

public class DuplicateElements {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 30, 20, 40, 10
        };

        Set<Integer> seen = new HashSet<>();

        for (int number : numbers) {

            if (!seen.add(number)) {
                System.out.println(
                    "Duplicate: " + number
                );
            }
        }
    }
}

import java.util.HashSet;
import java.util.Set;

public class DuplicateElements {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 30, 20, 40, 10
        };

        Set<Integer> seen = new HashSet<>();

        for (int number : numbers) {

            if (!seen.add(number)) {
                System.out.println(
                    "Duplicate: " + number
                );
            }
        }
    }
}

import java.util.HashSet;
import java.util.Set;

public class DuplicateElements {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 30, 20, 40, 10
        };

        Set<Integer> seen = new HashSet<>();

        for (int number : numbers) {

            if (!seen.add(number)) {
                System.out.println(
                    "Duplicate: " + number
                );
            }
        }
    }
}

The important idea is:

seen.add(number)

seen.add(number)

seen.add(number)

returns false when the value already exists in the set.

This is a common use case for HashSet.

Java Program 9: Remove Duplicates From an Array

import java.util.*;

public class RemoveDuplicates {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 10, 30, 20, 40
        };

        Set<Integer> unique =
                new LinkedHashSet<>();

        for (int number : numbers) {
            unique.add(number);
        }

        System.out.println(unique);
    }
}

import java.util.*;

public class RemoveDuplicates {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 10, 30, 20, 40
        };

        Set<Integer> unique =
                new LinkedHashSet<>();

        for (int number : numbers) {
            unique.add(number);
        }

        System.out.println(unique);
    }
}

import java.util.*;

public class RemoveDuplicates {

    public static void main(String[] args) {

        int[] numbers = {
            10, 20, 10, 30, 20, 40
        };

        Set<Integer> unique =
                new LinkedHashSet<>();

        for (int number : numbers) {
            unique.add(number);
        }

        System.out.println(unique);
    }
}

Why use LinkedHashSet?

Because it preserves insertion order while removing duplicates.

This gives you an opportunity to discuss the differences between:

HashSet
LinkedHashSet
TreeSet

Java Program 10: Find Missing Number

Suppose the array contains numbers from 1 to n, with one number missing.

public class MissingNumber {

    public static void main(String[] args) {

        int[] numbers = {1, 2, 3, 5};

        int n = 5;

        int expected = n * (n + 1) / 2;

        int actual = 0;

        for (int number : numbers) {
            actual += number;
        }

        int missing = expected - actual;

        System.out.println(
            "Missing Number: " + missing
        );
    }
}

public class MissingNumber {

    public static void main(String[] args) {

        int[] numbers = {1, 2, 3, 5};

        int n = 5;

        int expected = n * (n + 1) / 2;

        int actual = 0;

        for (int number : numbers) {
            actual += number;
        }

        int missing = expected - actual;

        System.out.println(
            "Missing Number: " + missing
        );
    }
}

public class MissingNumber {

    public static void main(String[] args) {

        int[] numbers = {1, 2, 3, 5};

        int n = 5;

        int expected = n * (n + 1) / 2;

        int actual = 0;

        for (int number : numbers) {
            actual += number;
        }

        int missing = expected - actual;

        System.out.println(
            "Missing Number: " + missing
        );
    }
}

Output:

Missing Number: 4

Missing Number: 4

Missing Number: 4

This is a useful example of mathematical reasoning combined with array traversal.

Java Program 11: Factorial

public class Factorial {

    public static void main(String[] args) {

        int number = 5;
        int factorial = 1;

        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }

        System.out.println(factorial);
    }
}

public class Factorial {

    public static void main(String[] args) {

        int number = 5;
        int factorial = 1;

        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }

        System.out.println(factorial);
    }
}

public class Factorial {

    public static void main(String[] args) {

        int number = 5;
        int factorial = 1;

        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }

        System.out.println(factorial);
    }
}

Output:

You should also know the recursive version.

static int factorial(int n) {

    if (n == 0 || n == 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

static int factorial(int n) {

    if (n == 0 || n == 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

static int factorial(int n) {

    if (n == 0 || n == 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

Java Program 12: Fibonacci Series

public class Fibonacci {

    public static void main(String[] args) {

        int first = 0;
        int second = 1;

        for (int i = 1; i <= 10; i++) {

            System.out.print(first + " ");

            int next = first + second;

            first = second;
            second = next;
        }
    }
}

public class Fibonacci {

    public static void main(String[] args) {

        int first = 0;
        int second = 1;

        for (int i = 1; i <= 10; i++) {

            System.out.print(first + " ");

            int next = first + second;

            first = second;
            second = next;
        }
    }
}

public class Fibonacci {

    public static void main(String[] args) {

        int first = 0;
        int second = 1;

        for (int i = 1; i <= 10; i++) {

            System.out.print(first + " ");

            int next = first + second;

            first = second;
            second = next;
        }
    }
}

Output:

0 1 1 2 3 5 8 13 21 34

0 1 1 2 3 5 8 13 21 34

0 1 1 2 3 5 8 13 21 34

Understand how the variables change after each iteration.

Java Program 13: Swap Two Numbers

Using a temporary variable:

int a = 10;
int b = 20;

int temp = a;
a = b;
b = temp;

System.out.println(a);
System.out.println(b);

int a = 10;
int b = 20;

int temp = a;
a = b;
b = temp;

System.out.println(a);
System.out.println(b);

int a = 10;
int b = 20;

int temp = a;
a = b;
b = temp;

System.out.println(a);
System.out.println(b);

Without a temporary variable:

int a = 10;
int b = 20;

a = a + b;
b = a - b;
a = a - b;

int a = 10;
int b = 20;

a = a + b;
b = a - b;
a = a - b;

int a = 10;
int b = 20;

a = a + b;
b = a - b;
a = a - b;

The second approach should be used carefully because integer overflow can become an issue for sufficiently large values.

That kind of limitation is exactly what makes a coding answer stronger in an interview.

Java Program 14: Check Armstrong Number

public class Armstrong {

    public static void main(String[] args) {

        int number = 153;
        int original = number;
        int result = 0;

        while (number != 0) {

            int digit = number % 10;

            result += digit * digit * digit;

            number /= 10;
        }

        if (result == original) {
            System.out.println("Armstrong Number");
        } else {
            System.out.println("Not an Armstrong Number");
        }
    }
}

public class Armstrong {

    public static void main(String[] args) {

        int number = 153;
        int original = number;
        int result = 0;

        while (number != 0) {

            int digit = number % 10;

            result += digit * digit * digit;

            number /= 10;
        }

        if (result == original) {
            System.out.println("Armstrong Number");
        } else {
            System.out.println("Not an Armstrong Number");
        }
    }
}

public class Armstrong {

    public static void main(String[] args) {

        int number = 153;
        int original = number;
        int result = 0;

        while (number != 0) {

            int digit = number % 10;

            result += digit * digit * digit;

            number /= 10;
        }

        if (result == original) {
            System.out.println("Armstrong Number");
        } else {
            System.out.println("Not an Armstrong Number");
        }
    }
}

For fresher coding preparation, number-based problems are useful for developing logic before moving to larger DSA problems.

Java Program 15: Count Digits

public class CountDigits {

    public static void main(String[] args) {

        int number = 123456;
        int count = 0;

        while (number != 0) {

            number /= 10;
            count++;
        }

        System.out.println("Digits: " + count);
    }
}

public class CountDigits {

    public static void main(String[] args) {

        int number = 123456;
        int count = 0;

        while (number != 0) {

            number /= 10;
            count++;
        }

        System.out.println("Digits: " + count);
    }
}

public class CountDigits {

    public static void main(String[] args) {

        int number = 123456;
        int count = 0;

        while (number != 0) {

            number /= 10;
            count++;
        }

        System.out.println("Digits: " + count);
    }
}

This tests basic mathematical logic and loops.

Java Program 16: Reverse a Number

public class ReverseNumber {

    public static void main(String[] args) {

        int number = 12345;
        int reverse = 0;

        while (number != 0) {

            int digit = number % 10;

            reverse =
                reverse * 10 + digit;

            number /= 10;
        }

        System.out.println(reverse);
    }
}

public class ReverseNumber {

    public static void main(String[] args) {

        int number = 12345;
        int reverse = 0;

        while (number != 0) {

            int digit = number % 10;

            reverse =
                reverse * 10 + digit;

            number /= 10;
        }

        System.out.println(reverse);
    }
}

public class ReverseNumber {

    public static void main(String[] args) {

        int number = 12345;
        int reverse = 0;

        while (number != 0) {

            int digit = number % 10;

            reverse =
                reverse * 10 + digit;

            number /= 10;
        }

        System.out.println(reverse);
    }
}

Output:

Java Program 17: Check Even or Odd

public class EvenOdd {

    public static void main(String[] args) {

        int number = 25;

        if (number % 2 == 0) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }
    }
}

public class EvenOdd {

    public static void main(String[] args) {

        int number = 25;

        if (number % 2 == 0) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }
    }
}

public class EvenOdd {

    public static void main(String[] args) {

        int number = 25;

        if (number % 2 == 0) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }
    }
}

This is simple, but simple programs form the foundation for more complicated problems.

Java Program 18: Sort an Array

Using Arrays.sort():

import java.util.Arrays;

public class SortArray {

    public static void main(String[] args) {

        int[] numbers = {
            50, 20, 10, 40, 30
        };

        Arrays.sort(numbers);

        System.out.println(
            Arrays.toString(numbers)
        );
    }
}

import java.util.Arrays;

public class SortArray {

    public static void main(String[] args) {

        int[] numbers = {
            50, 20, 10, 40, 30
        };

        Arrays.sort(numbers);

        System.out.println(
            Arrays.toString(numbers)
        );
    }
}

import java.util.Arrays;

public class SortArray {

    public static void main(String[] args) {

        int[] numbers = {
            50, 20, 10, 40, 30
        };

        Arrays.sort(numbers);

        System.out.println(
            Arrays.toString(numbers)
        );
    }
}

Output:

[10, 20, 30, 40, 50]

[10, 20, 30, 40, 50]

[10, 20, 30, 40, 50]

But for coding assessments, you should also understand basic sorting algorithms such as:

Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Quick Sort

Bubble Sort Example

public class BubbleSort {

    public static void main(String[] args) {

        int[] numbers = {
            5, 2, 8, 1, 3
        };

        for (int i = 0;
             i < numbers.length - 1;
             i++) {

            for (int j = 0;
                 j < numbers.length - i - 1;
                 j++) {

                if (numbers[j] > numbers[j + 1]) {

                    int temp = numbers[j];

                    numbers[j] = numbers[j + 1];

                    numbers[j + 1] = temp;
                }
            }
        }

        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

public class BubbleSort {

    public static void main(String[] args) {

        int[] numbers = {
            5, 2, 8, 1, 3
        };

        for (int i = 0;
             i < numbers.length - 1;
             i++) {

            for (int j = 0;
                 j < numbers.length - i - 1;
                 j++) {

                if (numbers[j] > numbers[j + 1]) {

                    int temp = numbers[j];

                    numbers[j] = numbers[j + 1];

                    numbers[j + 1] = temp;
                }
            }
        }

        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

public class BubbleSort {

    public static void main(String[] args) {

        int[] numbers = {
            5, 2, 8, 1, 3
        };

        for (int i = 0;
             i < numbers.length - 1;
             i++) {

            for (int j = 0;
                 j < numbers.length - i - 1;
                 j++) {

                if (numbers[j] > numbers[j + 1]) {

                    int temp = numbers[j];

                    numbers[j] = numbers[j + 1];

                    numbers[j + 1] = temp;
                }
            }
        }

        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

A good interview answer should also explain why Bubble Sort is not generally preferred for large datasets.

Java OOP Coding Questions for Freshers

OOP is one of the most important Java interview areas.

The four core concepts are:

Encapsulation
Inheritance
Polymorphism
Abstraction

You should be able to explain each concept using code.

Encapsulation Example

class Employee {

    private String name;
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

class Employee {

    private String name;
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

class Employee {

    private String name;
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

The fields are private and accessed through methods.

A common interview question is:

Why do we use encapsulation?

It helps control access to an object's internal state and allows validation or business rules to be added around that access.

Inheritance Example

class Animal {

    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Barking");
    }
}

class Animal {

    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Barking");
    }
}

class Animal {

    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Barking");
    }
}

Here, Dog inherits behavior from Animal.

Method Overloading

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

The method name is the same, but the parameter list is different.

Method Overriding

class Animal {

    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Animal {

    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Animal {

    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

This demonstrates runtime polymorphism.

Abstraction Example

abstract class Vehicle {

    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {

    @Override
    void start() {
        System.out.println("Car started");
    }
}

abstract class Vehicle {

    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {

    @Override
    void start() {
        System.out.println("Car started");
    }
}

abstract class Vehicle {

    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {

    @Override
    void start() {
        System.out.println("Car started");
    }
}

A fresher should know both the concept and the reason for using abstraction.

Java Collections Coding Questions

Java Collections are frequently used in practical development and coding problems.

Important interfaces and classes include:

List
Set
Map
Queue

ArrayList
LinkedList
HashSet
LinkedHashSet
TreeSet
HashMap
LinkedHashMap
TreeMap
PriorityQueue

List
Set
Map
Queue

ArrayList
LinkedList
HashSet
LinkedHashSet
TreeSet
HashMap
LinkedHashMap
TreeMap
PriorityQueue

List
Set
Map
Queue

ArrayList
LinkedList
HashSet
LinkedHashSet
TreeSet
HashMap
LinkedHashMap
TreeMap
PriorityQueue

You should understand when to use each one.

ArrayList Example

import java.util.ArrayList;

public class ArrayListExample {

    public static void main(String[] args) {

        ArrayList<String> names =
                new ArrayList<>();

        names.add("Amit");
        names.add("Rahul");
        names.add("Priya");

        System.out.println(names);
    }
}

import java.util.ArrayList;

public class ArrayListExample {

    public static void main(String[] args) {

        ArrayList<String> names =
                new ArrayList<>();

        names.add("Amit");
        names.add("Rahul");
        names.add("Priya");

        System.out.println(names);
    }
}

import java.util.ArrayList;

public class ArrayListExample {

    public static void main(String[] args) {

        ArrayList<String> names =
                new ArrayList<>();

        names.add("Amit");
        names.add("Rahul");
        names.add("Priya");

        System.out.println(names);
    }
}

HashMap Example

import java.util.HashMap;

public class HashMapExample {

    public static void main(String[] args) {

        HashMap<Integer, String> students =
                new HashMap<>();

        students.put(101, "Amit");
        students.put(102, "Priya");

        System.out.println(
            students.get(101)
        );
    }
}

import java.util.HashMap;

public class HashMapExample {

    public static void main(String[] args) {

        HashMap<Integer, String> students =
                new HashMap<>();

        students.put(101, "Amit");
        students.put(102, "Priya");

        System.out.println(
            students.get(101)
        );
    }
}

import java.util.HashMap;

public class HashMapExample {

    public static void main(String[] args) {

        HashMap<Integer, String> students =
                new HashMap<>();

        students.put(101, "Amit");
        students.put(102, "Priya");

        System.out.println(
            students.get(101)
        );
    }
}

A useful interview question is:

Why would you choose a HashMap instead of an ArrayList?

The answer depends on the problem.

If you need key-value lookup, a map is appropriate.

If you need an ordered collection of values accessed by index, a list may be more suitable.

Java 8 Coding Questions

Modern Java preparation should include Java 8 features such as:

Lambda expressions
Functional interfaces
Method references
Stream API
Optional
Functional programming concepts

Example:

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {

        List<Integer> numbers =
                Arrays.asList(
                    10, 15, 20, 25, 30
                );

        numbers.stream()
               .filter(n -> n > 20)
               .forEach(System.out::println);
    }
}

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {

        List<Integer> numbers =
                Arrays.asList(
                    10, 15, 20, 25, 30
                );

        numbers.stream()
               .filter(n -> n > 20)
               .forEach(System.out::println);
    }
}

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {

        List<Integer> numbers =
                Arrays.asList(
                    10, 15, 20, 25, 30
                );

        numbers.stream()
               .filter(n -> n > 20)
               .forEach(System.out::println);
    }
}

Output:

25
30

25
30

25
30

Java Stream: Find Even Numbers

List<Integer> numbers =
        Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> evenNumbers =
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .toList();

System.out.println(evenNumbers);

List<Integer> numbers =
        Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> evenNumbers =
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .toList();

System.out.println(evenNumbers);

List<Integer> numbers =
        Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> evenNumbers =
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .toList();

System.out.println(evenNumbers);

Java Stream: Sort Values

List<Integer> numbers =
        Arrays.asList(50, 20, 40, 10, 30);

numbers.stream()
       .sorted()
       .forEach(System.out::println);

List<Integer> numbers =
        Arrays.asList(50, 20, 40, 10, 30);

numbers.stream()
       .sorted()
       .forEach(System.out::println);

List<Integer> numbers =
        Arrays.asList(50, 20, 40, 10, 30);

numbers.stream()
       .sorted()
       .forEach(System.out::println);

Java Stream: Find Maximum

int max =
    numbers.stream()
           .max(Integer::compareTo)
           .orElse(0);

System.out.println(max);

int max =
    numbers.stream()
           .max(Integer::compareTo)
           .orElse(0);

System.out.println(max);

int max =
    numbers.stream()
           .max(Integer::compareTo)
           .orElse(0);

System.out.println(max);

The important thing is not memorizing the syntax.

Understand:

Source
 ↓
Intermediate operation
 ↓
Terminal operation

Source
 ↓
Intermediate operation
 ↓
Terminal operation

Source
 ↓
Intermediate operation
 ↓
Terminal operation

For example:

numbers
 ↓
stream()
 ↓
filter()
 ↓
sorted()
 ↓
forEach()

numbers
 ↓
stream()
 ↓
filter()
 ↓
sorted()
 ↓
forEach()

numbers
 ↓
stream()
 ↓
filter()
 ↓
sorted()
 ↓
forEach()

SQL Queries Every Java Fresher Should Know

Java backend development frequently works with relational databases.

Therefore, SQL queries for Java developers should be part of your preparation.

Start with:

SELECT * FROM

SELECT * FROM

SELECT * FROM

Then progress to filtering:

SELECT *
FROM employees
WHERE salary > 40000

SELECT *
FROM employees
WHERE salary > 40000

SELECT *
FROM employees
WHERE salary > 40000

Sorting:

SELECT *
FROM employees
ORDER BY salary DESC

SELECT *
FROM employees
ORDER BY salary DESC

SELECT *
FROM employees
ORDER BY salary DESC

Counting:

SELECT COUNT(*)
FROM

SELECT COUNT(*)
FROM

SELECT COUNT(*)
FROM

Average:

SELECT AVG(salary)
FROM

SELECT AVG(salary)
FROM

SELECT AVG(salary)
FROM

Maximum:

SELECT MAX(salary)
FROM

SELECT MAX(salary)
FROM

SELECT MAX(salary)
FROM

Minimum:

SELECT MIN(salary)
FROM

SELECT MIN(salary)
FROM

SELECT MIN(salary)
FROM

GROUP BY Query

SELECT department,
       COUNT(*) AS employee_count
FROM employees
GROUP BY

SELECT department,
       COUNT(*) AS employee_count
FROM employees
GROUP BY

SELECT department,
       COUNT(*) AS employee_count
FROM employees
GROUP BY

This is useful when you need an aggregate result for each category.

HAVING Query

SELECT department,
       AVG(salary) AS average_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 50000

SELECT department,
       AVG(salary) AS average_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 50000

SELECT department,
       AVG(salary) AS average_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 50000

Remember:

WHERE filters rows before grouping.

HAVING filters grouped results.

SQL JOIN Example

Suppose you have:

employees
departments

employees
departments

employees
departments

You can write:

SELECT
    e.name,
    d.department_name
FROM employees e
INNER JOIN departments d
ON

SELECT
    e.name,
    d.department_name
FROM employees e
INNER JOIN departments d
ON

SELECT
    e.name,
    d.department_name
FROM employees e
INNER JOIN departments d
ON

Understanding joins is extremely important for Java backend interviews.

Find Second-Highest Salary

One common approach is:

SELECT MAX(salary)
FROM employees
WHERE salary < (
    SELECT MAX(salary)
    FROM employees
)

SELECT MAX(salary)
FROM employees
WHERE salary < (
    SELECT MAX(salary)
    FROM employees
)

SELECT MAX(salary)
FROM employees
WHERE salary < (
    SELECT MAX(salary)
    FROM employees
)

This is a classic SQL interview problem.

You should also understand alternative approaches using:

ORDER BY
LIMIT
DENSE_RANK()

depending on the database system and requirements.

Find Duplicate Records

SELECT email,
       COUNT(*) AS total
FROM employees
GROUP BY email
HAVING COUNT(*) > 1

SELECT email,
       COUNT(*) AS total
FROM employees
GROUP BY email
HAVING COUNT(*) > 1

SELECT email,
       COUNT(*) AS total
FROM employees
GROUP BY email
HAVING COUNT(*) > 1

This query identifies duplicate email values.

Find Employees Whose Name Starts With A

SELECT *
FROM employees
WHERE name LIKE 'A%'

SELECT *
FROM employees
WHERE name LIKE 'A%'

SELECT *
FROM employees
WHERE name LIKE 'A%'

Ends with A:

SELECT *
FROM employees
WHERE name LIKE '%A'

SELECT *
FROM employees
WHERE name LIKE '%A'

SELECT *
FROM employees
WHERE name LIKE '%A'

Contains A:

SELECT *
FROM employees
WHERE name LIKE '%A%'

SELECT *
FROM employees
WHERE name LIKE '%A%'

SELECT *
FROM employees
WHERE name LIKE '%A%'

REST API Coding Concepts for Java Freshers

After learning Java and SQL, a fresher targeting full stack or backend roles should understand how applications communicate through APIs.

A simple REST API may contain:

GET
POST
PUT
DELETE

GET
POST
PUT
DELETE

GET
POST
PUT
DELETE

For an employee application:

GET    /api/employees
GET    /api/employees/101
POST   /api/employees
PUT    /api/employees/101
DELETE /api/employees/101

GET    /api/employees
GET    /api/employees/101
POST   /api/employees
PUT    /api/employees/101
DELETE /api/employees/101

GET    /api/employees
GET    /api/employees/101
POST   /api/employees
PUT    /api/employees/101
DELETE /api/employees/101

These represent common CRUD operations.

Simple Spring Boot Controller

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

    @GetMapping
    public List<Employee> getEmployees() {
        return employeeService.getAllEmployees();
    }

    @PostMapping
    public Employee addEmployee(
            @RequestBody Employee employee) {

        return employeeService.addEmployee(employee);
    }
}

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

    @GetMapping
    public List<Employee> getEmployees() {
        return employeeService.getAllEmployees();
    }

    @PostMapping
    public Employee addEmployee(
            @RequestBody Employee employee) {

        return employeeService.addEmployee(employee);
    }
}

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

    @GetMapping
    public List<Employee> getEmployees() {
        return employeeService.getAllEmployees();
    }

    @PostMapping
    public Employee addEmployee(
            @RequestBody Employee employee) {

        return employeeService.addEmployee(employee);
    }
}

You should understand:

@RestController
@RequestMapping
@GetMapping
@PostMapping
@RequestBody

Do not memorize annotations without understanding the HTTP request-response cycle.

Simple REST Request

POST /api/employees
Content-Type: application/json

POST /api/employees
Content-Type: application/json

POST /api/employees
Content-Type: application/json

Request body:

{
    "name": "Amit",
    "email": "amit@example.com",
    "department": "IT"
}

{
    "name": "Amit",
    "email": "amit@example.com",
    "department": "IT"
}

{
    "name": "Amit",
    "email": "amit@example.com",
    "department": "IT"
}

The backend receives this data and can validate it before saving it to the database.

Understanding the Full Request Flow

A fresher should be able to explain:

User
 ↓
Frontend
 ↓
HTTP Request
 ↓
REST Controller
 ↓
Service Layer
 ↓
Repository
 ↓
Database
 ↓
Repository
 ↓
Service
 ↓
Controller
 ↓
JSON Response
 ↓
Frontend
 ↓
User

User
 ↓
Frontend
 ↓
HTTP Request
 ↓
REST Controller
 ↓
Service Layer
 ↓
Repository
 ↓
Database
 ↓
Repository
 ↓
Service
 ↓
Controller
 ↓
JSON Response
 ↓
Frontend
 ↓
User

User
 ↓
Frontend
 ↓
HTTP Request
 ↓
REST Controller
 ↓
Service Layer
 ↓
Repository
 ↓
Database
 ↓
Repository
 ↓
Service
 ↓
Controller
 ↓
JSON Response
 ↓
Frontend
 ↓
User

This is much more valuable than simply knowing the definition of Spring Boot.

Common Coding Assessment Patterns

Instead of trying to memorize hundreds of unrelated problems, learn patterns.

Pattern 1: Frequency Counting

Useful for:

Duplicate characters
Duplicate numbers
Character frequency
Word frequency

Typical tool:

HashMap

HashMap

HashMap

Pattern 2: Duplicate Detection

Useful for:

Duplicate array values
Duplicate IDs
Repeated elements

Typical tool:

HashSet

HashSet

HashSet

Pattern 3: Two Pointers

Useful for:

Sorted arrays
Pair problems
Palindrome problems
Array manipulation

Pattern 4: Sliding Window

Useful for:

Subarray problems
Substring problems
Maximum/minimum window calculations

Pattern 5: Sorting

Useful for:

Ranking
Duplicate detection
Finding minimum/maximum
Interval problems

Pattern 6: Recursion

Useful for:

Factorial
Fibonacci
Tree problems
Backtracking

Learning patterns makes Java coding interview preparation more efficient than memorizing isolated solutions.

Time Complexity Every Fresher Should Understand

You do not need advanced mathematical knowledge to start.

Understand these common complexities:

O(1)
O(log n)
O(n)
O(n log n)
O(n²)

O(1)
O(log n)
O(n)
O(n log n)
O(n²)

O(1)
O(log n)
O(n)
O(n log n)
O(n²)

For example:

for (int i = 0; i < n; i++) {
    System.out.println(i);
}

for (int i = 0; i < n; i++) {
    System.out.println(i);
}

for (int i = 0; i < n; i++) {
    System.out.println(i);
}

This generally performs n iterations.

Therefore:

Time Complexity = O(n)

Time Complexity = O(n)

Time Complexity = O(n)

Nested loops often lead to:

O(n²)

O(n²)

O(n²)

Understanding complexity helps you explain why one solution is more efficient than another.

Example: O(n) vs O(n²)

Suppose you want to find duplicates.

Nested-loop approach:

for (int i = 0; i < n; i++) {

    for (int j = i + 1; j < n; j++) {

        if (numbers[i] == numbers[j]) {
            System.out.println(numbers[i]);
        }
    }
}

for (int i = 0; i < n; i++) {

    for (int j = i + 1; j < n; j++) {

        if (numbers[i] == numbers[j]) {
            System.out.println(numbers[i]);
        }
    }
}

for (int i = 0; i < n; i++) {

    for (int j = i + 1; j < n; j++) {

        if (numbers[i] == numbers[j]) {
            System.out.println(numbers[i]);
        }
    }
}

This can require roughly quadratic comparisons.

A HashSet approach:

Set<Integer> set = new HashSet<>();

for (int number : numbers) {

    if (!set.add(number)) {
        System.out.println(number);
    }
}

Set<Integer> set = new HashSet<>();

for (int number : numbers) {

    if (!set.add(number)) {
        System.out.println(number);
    }
}

Set<Integer> set = new HashSet<>();

for (int number : numbers) {

    if (!set.add(number)) {
        System.out.println(number);
    }
}

This generally provides expected linear-time behavior for insertion/lookup, with additional memory usage.

That trade-off is a good interview discussion.

40+ Java Coding Questions to Practice

After understanding the examples above, practice these problems without looking at solutions.

Basic Java Programs

Reverse a string
Reverse a number
Check palindrome
Check prime number
Find factorial
Generate Fibonacci series
Check Armstrong number
Check even or odd
Count digits
Sum digits
Find GCD
Find LCM
Swap two numbers
Find largest number
Find smallest number

String Coding Questions

Count vowels
Count consonants
Count characters
Reverse words
Check palindrome string
Remove duplicate characters
Find duplicate characters
Find first non-repeated character
Check anagram
Count words

Array Coding Questions

Find largest element
Find second-largest element
Find smallest element
Find duplicate elements
Remove duplicates
Find missing number
Reverse an array
Sort an array
Merge two arrays
Find common elements
Find pair with a given sum
Move zeros to the end
Find frequency of elements
Find maximum subarray sum
Rotate an array

Collections and Java 8

Sort a list using Collections
Remove duplicates using Set
Count frequency using HashMap
Filter values using Stream API
Sort objects using Stream API
Find maximum using Stream API
Group objects using Collectors.groupingBy
Find duplicate values using Java Streams

SQL

Find second-highest salary
Find duplicate records
Find employees by department
Count employees by department
Find maximum salary
Find average salary
Use INNER JOIN
Use LEFT JOIN
Use GROUP BY
Use HAVING
Use subquery
Find records using LIKE

Practicing these problems gives you a much broader foundation than memorizing a short list of interview questions.

How to Practice Java Coding Questions Correctly

Do not immediately open the solution.

Use this process:

Read Problem
     ↓
Understand Input
     ↓
Understand Expected Output
     ↓
Write Logic in Words
     ↓
Write Pseudocode
     ↓
Write Java Code
     ↓
Run Test Cases
     ↓
Check Edge Cases
     ↓
Analyze Complexity
     ↓
Improve Solution

Read Problem
     ↓
Understand Input
     ↓
Understand Expected Output
     ↓
Write Logic in Words
     ↓
Write Pseudocode
     ↓
Write Java Code
     ↓
Run Test Cases
     ↓
Check Edge Cases
     ↓
Analyze Complexity
     ↓
Improve Solution

Read Problem
     ↓
Understand Input
     ↓
Understand Expected Output
     ↓
Write Logic in Words
     ↓
Write Pseudocode
     ↓
Write Java Code
     ↓
Run Test Cases
     ↓
Check Edge Cases
     ↓
Analyze Complexity
     ↓
Improve Solution

For example, before coding a duplicate-number problem, write:

1. Create a collection to store values already seen.
2. Traverse the array.
3. Check whether the value already exists.
4. If yes, it is a duplicate.
5. Otherwise add it

1. Create a collection to store values already seen.
2. Traverse the array.
3. Check whether the value already exists.
4. If yes, it is a duplicate.
5. Otherwise add it

1. Create a collection to store values already seen.
2. Traverse the array.
3. Check whether the value already exists.
4. If yes, it is a duplicate.
5. Otherwise add it

Then convert the logic into Java.

This develops actual problem-solving ability.

Test Your Code With Edge Cases

Do not test only the example given in the question.

For an array problem, test:

Empty array
One element
Two elements
Duplicate values
Negative values
Already sorted array
Reverse sorted array
Very large values
All values equal

Empty array
One element
Two elements
Duplicate values
Negative values
Already sorted array
Reverse sorted array
Very large values
All values equal

Empty array
One element
Two elements
Duplicate values
Negative values
Already sorted array
Reverse sorted array
Very large values
All values equal

For a string problem:

Empty string
One character
Spaces
Uppercase characters
Lowercase characters
Repeated characters
Special characters

Empty string
One character
Spaces
Uppercase characters
Lowercase characters
Repeated characters
Special characters

Empty string
One character
Spaces
Uppercase characters
Lowercase characters
Repeated characters
Special characters

This is one of the easiest ways to improve your coding quality.

Common Mistakes Freshers Make in Java Coding Interviews

Memorizing programs

If the interviewer changes the input format, memorized code may stop working.

Understand the logic instead.

Ignoring edge cases

A program that works for one example is not necessarily a correct solution.

Writing unnecessarily complicated code

Start with a clear solution.

Then optimize if required.

Not explaining your approach

Even when your code is correct, you should be able to explain why it works.

Ignoring complexity

Learn to discuss:

Time Complexity
Space Complexity

Time Complexity
Space Complexity

Time Complexity
Space Complexity

Using collections without understanding them

Do not use HashMap simply because you saw it in another solution.

Know why it is appropriate.

Depending entirely on AI-generated code

AI can help explain programming concepts, generate examples and assist with debugging, but you should verify and understand the result.

The 2025 Stack Overflow Developer Survey found that 84% of respondents were using or planning to use AI tools in their development process, while 66% reported frustration with AI answers that were “almost right.”

For a fresher, this creates an important distinction:

AI-assisted coding is useful. Unverified coding is risky.

How to Use AI While Learning Java

Use AI as a learning assistant rather than a replacement for practice.

Good uses include:

Explain this Java error
Explain this exception
Give me test cases
Explain this SQL query
Compare two approaches
Find possible edge cases
Explain time complexity
Review my code
Suggest improvements
Explain Spring Boot annotations

Avoid simply asking:

“Solve this entire coding test for me.”

Instead:

“Give me a hint without giving the complete solution.”

Then solve it yourself.

This creates stronger learning.

How Java Coding Connects With Full Stack Development

Java coding should not remain isolated console practice.

Eventually, you should connect the concepts.

For example:

Java
 ↓
OOP
 ↓
Collections
 ↓
SQL
 ↓
JDBC
 ↓
Hibernate
 ↓
Spring
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Database

Java
 ↓
OOP
 ↓
Collections
 ↓
SQL
 ↓
JDBC
 ↓
Hibernate
 ↓
Spring
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Database

Java
 ↓
OOP
 ↓
Collections
 ↓
SQL
 ↓
JDBC
 ↓
Hibernate
 ↓
Spring
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Database

That is how individual programming concepts become practical development skills.

What a Fresher Should Know Before Applying for Java Developer Roles

A practical checklist can include:

Core Java

Variables
Data types
Operators
Loops
Conditions
Methods
Arrays
Strings

OOP

Encapsulation
Inheritance
Polymorphism
Abstraction
Interfaces
Overloading
Overriding

Collections

List
Set
Map
Queue
ArrayList
LinkedList
HashSet
HashMap

Java 8+

Lambda
Functional interfaces
Streams
Method references
Optional

DSA

Arrays
Strings
Linked Lists
Stacks
Queues
Searching
Sorting
Recursion

Database

SQL
MySQL
Joins
Group By
Having
Subqueries
Aggregate functions

Backend

JDBC
Hibernate
Spring
Spring MVC
Spring Boot
REST APIs
JSON

Frontend

HTML
CSS
JavaScript
DOM
Forms
AJAX
Responsive design

Tools

Git
GitHub
Postman
Docker

Job readiness

Aptitude
Communication
Group discussion
Resume
Mock interviews
Technical interview preparation

How VibrantMinds Prepares Freshers for Java Development

VibrantMinds Technologies Pvt. Ltd. provides structured, job-oriented technology training for freshers and graduates, with its Full Stack Java Development program as a major development-focused pathway.

The current published Full Stack Java curriculum combines programming fundamentals with backend, database, frontend, practical coding and job-readiness preparation.

Full Stack Java Course

The Full Stack Java program covers the technical areas needed to progress from Java fundamentals toward full stack application development.

Core Java

The curriculum includes:

Java fundamentals
Keywords
Variables
Data types
Operators
Conditional statements
Loops
Pattern programming
Classes
Objects
Inheritance
Abstraction
Encapsulation
Polymorphism
Strings
StringBuffer
StringBuilder
Arrays
Exception handling
Multithreading
Java Collections Framework
List
Set
Queue
Map

Data Structures and Algorithms

The DSA component includes:

Arrays
Linked Lists
Singly Linked Lists
Stacks
Queues
Searching
Linear Search
Binary Search
Selection Sort
Bubble Sort
Insertion Sort
Quick Sort
Merge Sort
Recursion
Recursive problem solving

These concepts are particularly relevant to coding assessments and technical interview preparation.

Java 8 and Functional Programming

The curriculum also includes:

Functional interfaces
Built-in functional interfaces
Lambda expressions
Method references
Stream API
Stream creation
Filtering
Mapping
Sorting
Intermediate operations
Terminal operations
Aggregation
Reduction
Collecting
Searching

JDBC, Servlets and JSP

Students can learn:

JDBC API
CRUD using JDBC
Servlet lifecycle
Types of Servlets
JSP lifecycle
JSP tags
JSP implicit objects
HTTP requests
HTTP responses
Session management
Database-connected web applications

MVC and Hibernate

The curriculum includes:

MVC architecture
CRUD applications
Hibernate configuration
Session
SessionFactory
XML configuration
Annotation-based configuration
Object states
Relationships
Fetching
Caching
HQL
Hibernate-based applications

Spring Framework

The Spring portion includes:

Inversion of Control
Dependency Injection
Setter injection
Constructor injection
Spring Beans
Bean scopes
Bean lifecycle
Spring JDBC
Spring Hibernate integration
Spring MVC
Validation

Spring Boot and REST APIs

Students work with:

Spring Boot fundamentals
Project structure
Application properties
Dependency Injection
REST web services
JSON
Object-to-JSON concepts
REST API exception handling
REST API design
CRUD REST APIs
Database-connected REST projects
Spring Boot with Hibernate

SQL and MySQL

Database preparation includes:

SELECT
WHERE
Sorting
Filtering
DDL
DML
Constraints
INSERT
UPDATE
DELETE
Self Join
INNER JOIN
LEFT JOIN
RIGHT JOIN
CROSS JOIN
Subqueries
Aggregate functions
String functions
Conversion functions

Frontend Development

The published curriculum includes:

HTML5

Semantic HTML
Forms
Input elements
Web storage
Canvas
Browser APIs

CSS3

Selectors
Fonts
Text effects
Backgrounds
Borders
Transforms
Transitions
Animations
Flexbox
Responsive layouts
Media queries

JavaScript

Variables
Data types
Arrays
Conditions
Loops
Functions
Strings
Numbers
Dates
DOM
Events
Form validation

It also includes JavaScript-related technologies such as jQuery, AJAX and JSON, along with React.js in the broader published technology stack.

Developer Tools

The published Full Stack Java program also references tools and technologies including:

Git
GitHub
Postman
Docker
MySQL
MongoDB
React.js
Node.js
Express.js

The exact depth of each technology can depend on the curriculum structure and batch.

Job-Readiness Preparation at VibrantMinds

Technical skills are only one part of fresher preparation.

The published Full Stack Java program also includes:

Daily coding practice
DSA preparation
Aptitude training
Logical reasoning
Spoken English
Soft skills
Group discussion practice
Resume guidance
Mock interviews
Technical interview preparation
Placement assistance

The program describes structured practical sessions involving Java programming, DSA problem solving, SQL queries, frontend exercises, backend development, assignments and revision.

This creates a learning structure where coding practice is connected to broader job preparation rather than treated as an isolated subject.

Software Testing Training

VibrantMinds also publishes Software Testing-oriented training covering manual and automation testing concepts.

Areas include:

Software Testing fundamentals
Test case design
Software Testing Life Cycle
Bug life cycle
SQL
API testing
Selenium
Automation testing
TestNG
Java or programming fundamentals
Testing interview preparation

For freshers interested in QA, software testing or automation testing roles, this provides a different technology pathway from Java development.

Core Java Training

For learners who are at the beginning of their programming journey, Core Java provides a foundation in areas such as:

Java fundamentals
Variables
Data types
Operators
Control flow
Classes
Objects
OOP
Arrays
Strings
Collections
Exception handling
Programming practice

This foundation can be particularly useful before progressing into more advanced Java development concepts.

Python and Data Science Training

VibrantMinds also publishes Python and Data Science-oriented learning options.

These focus on areas such as:

Python programming
Programming fundamentals
Automation and scripting concepts
Data analysis foundations
Data Science concepts
Practical exercises

The exact duration, curriculum and batch structure can vary, so learners should confirm the current program details before enrolling.

Choosing a Learning Path

A fresher does not need to learn every programming language simultaneously.

A practical decision framework is:

Goal	Possible Learning Direction
Java development	Full Stack Java
Backend development	Java + Spring Boot + SQL
Full stack development	Java + frontend + database + APIs
Software testing	Manual + Automation Testing
Java fundamentals	Core Java
Python-oriented learning	Python + Data Science

The most important factor is consistency.

Jumping between Java, Python, testing, data science and other technologies every few weeks can make it difficult to develop job-ready depth.

30-Day Java Coding Practice Plan

Week 1: Java Fundamentals

Practice:

Variables
Conditions
Loops
Methods
Arrays
Strings

Target:

2–3 programs every day.

Week 2: Strings and Arrays

Practice:

Reverse string
Palindrome
Anagram
Duplicate elements
Missing number
Largest element
Second-largest element
Sorting
Array rotation

Week 3: Collections and DSA

Practice:

ArrayList
LinkedList
HashSet
HashMap
Stack
Queue
Searching
Sorting
Recursion

Week 4: SQL + Java 8 + Interview Simulation

Practice:

SQL joins
GROUP BY
HAVING
Subqueries
Aggregate functions
Lambda expressions
Streams
Coding problems
Project explanation

At the end of the month, attempt a mock coding assessment without looking at solutions.

A Better Daily Java Coding Routine

A practical daily session could look like:

30 minutes
Java concepts

45 minutes
Coding problems

30 minutes
DSA

30 minutes
SQL

30 minutes
Project development

15 minutes
Review mistakes

30 minutes
Java concepts

45 minutes
Coding problems

30 minutes
DSA

30 minutes
SQL

30 minutes
Project development

15 minutes
Review mistakes

30 minutes
Java concepts

45 minutes
Coding problems

30 minutes
DSA

30 minutes
SQL

30 minutes
Project development

15 minutes
Review mistakes

The exact schedule can change based on your college, work or training timetable.

Consistency matters more than following a perfect number of hours.

Coding Mistake Journal

One underrated technique is maintaining a coding mistake journal.

For every problem you get wrong, record:

Problem:
My Approach:
What Went Wrong:
Correct Concept:
Time Complexity:
Space Complexity:
What I Will Remember:

Problem:
My Approach:
What Went Wrong:
Correct Concept:
Time Complexity:
Space Complexity:
What I Will Remember:

Problem:
My Approach:
What Went Wrong:
Correct Concept:
Time Complexity:
Space Complexity:
What I Will Remember:

After 30–50 problems, patterns begin to appear.

You may discover that you repeatedly struggle with:

Array indexing
String manipulation
HashMap
Recursion
Nested loops
SQL joins
Null handling

Now you know exactly what to practice.

How to Know If You Are Ready for a Java Coding Test

Ask yourself:

Can I write basic Java programs without searching for syntax?

Can I solve string and array problems independently?

Can I use HashMap and HashSet appropriately?

Can I explain OOP with examples?

Can I write basic SQL queries?

Can I write JOIN queries?

Can I explain time complexity?

Can I debug a simple Java program?

Can I explain Java 8 Stream API?

Can I describe how a REST API works?

Can I explain a Spring Boot project?

Can I solve a problem even when the question is worded differently from the one I practiced?

If the answer to most of these is yes, you are moving beyond memorization toward practical coding ability.

Java Coding Interview Quick Revision

Before an interview, revise:

Java

JDK
JRE
JVM
OOP
Strings
Arrays
Exceptions
Collections
Multithreading
Java 8+

Coding

Reverse string
Palindrome
Prime
Fibonacci
Factorial
Duplicate elements
Missing number
Sorting
Searching
Frequency counting

SQL

SELECT
WHERE
ORDER BY
GROUP BY
HAVING
JOIN
Subquery
Aggregate functions

Backend

JDBC
Hibernate
Spring
Spring Boot
REST API
JSON
CRUD

Full Stack

HTML
CSS
JavaScript
DOM
AJAX
Frontend-backend communication

Job preparation

Resume
Project
Aptitude
Communication
Group discussion
Technical interview
HR interview

Frequently Asked Questions

What are the most important Java coding questions for freshers?

Start with strings, arrays, numbers, sorting, searching, duplicate detection, frequency counting, palindrome, prime numbers, Fibonacci, factorial, missing numbers and basic Java Collections problems.

How many Java programs should a fresher practice?

There is no fixed number that guarantees interview success. Focus on understanding problem-solving patterns. Practicing 40–60 carefully selected problems can provide a useful foundation if you understand the logic behind them.

Is Java coding important for Java developer jobs?

Yes. Java developer roles require programming ability, and coding practice helps freshers demonstrate logical thinking, syntax knowledge and problem-solving skills.

Should I learn DSA for Java developer interviews?

DSA is useful because coding assessments and technical interviews can include arrays, strings, searching, sorting, linked lists, stacks, queues and recursion.

Is SQL important for Java developers?

Yes. Java backend applications commonly interact with relational databases, making SQL and database concepts useful for development and interviews.

What Java Collections should freshers learn?

Start with List, Set, Map and Queue, then understand common implementations such as ArrayList, LinkedList, HashSet, LinkedHashSet, TreeSet, HashMap and TreeMap.

Should Java freshers learn Java 8?

Yes. Lambda expressions, functional interfaces and Stream API are important modern Java concepts.

Should freshers learn Spring Boot?

For candidates targeting modern Java backend or Full Stack Java roles, Spring Boot is an important technology to understand.

How can I improve Java coding logic?

Solve problems consistently, write pseudocode before coding, test edge cases, analyze complexity and review mistakes instead of immediately checking solutions.

Can AI help me prepare for Java coding interviews?

Yes. AI can help explain errors, generate test cases and clarify concepts. However, you should write and verify important code yourself rather than depending entirely on generated answers.

Is a Java certificate enough to get a job?

A certificate alone does not demonstrate complete programming ability. Practical coding, projects, technical knowledge, communication and interview performance also matter.

What should I put on my resume as a Java fresher?

Include relevant Java skills, projects you genuinely understand, technologies used, measurable project features where appropriate, education and relevant training or experience.

Final Java Fresher Coding Checklist

Before starting your job applications, make sure you can:

Write basic Java programs
Work with strings
Work with arrays
Solve number problems
Use methods
Explain OOP
Use Java Collections
Work with HashMap
Work with HashSet
Understand Java 8
Use Stream API
Understand basic DSA
Write SQL queries
Write JOIN queries
Use GROUP BY
Use subqueries
Understand JDBC
Understand Hibernate
Understand Spring
Understand Spring Boot
Explain REST APIs
Understand CRUD
Build or explain a project
Use Git
Test APIs
Explain your code
Discuss time complexity
Handle edge cases
Debug basic errors
Participate in technical interviews
Prepare for aptitude rounds
Communicate your technical knowledge clearly

Final Thoughts

Preparing for a Java developer role as a fresher is not about memorizing the largest possible collection of interview questions.

It is about developing the ability to understand a problem, design a solution, write Java code, test the result, identify mistakes and explain your approach.

Start with:

Core Java → OOP → Strings → Arrays → Collections → Java 8+ → DSA → SQL → JDBC → Hibernate → Spring → Spring Boot → REST APIs → Frontend → Projects → Interview Practice

If you are targeting Full Stack Java roles, connect these skills instead of learning them as isolated topics.

For example:

Java
 ↓
OOP
 ↓
Collections
 ↓
DSA
 ↓
SQL
 ↓
Hibernate
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Full Stack Application

Java
 ↓
OOP
 ↓
Collections
 ↓
DSA
 ↓
SQL
 ↓
Hibernate
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Full Stack Application

Java
 ↓
OOP
 ↓
Collections
 ↓
DSA
 ↓
SQL
 ↓
Hibernate
 ↓
Spring Boot
 ↓
REST API
 ↓
Frontend
 ↓
Full Stack Application

That progression turns coding practice into development ability.

VibrantMinds Technologies supports this type of structured learning through its job-oriented technology programs, with Full Stack Java covering Core Java, Advanced Java, DSA, Java 8+, JDBC, Servlets, JSP, Hibernate, Spring, Spring Boot, REST APIs, SQL, MySQL, HTML, CSS, JavaScript and practical coding. Its published job-readiness components also include aptitude, spoken English, soft skills, group discussions, resume guidance, mock interviews, technical interview preparation and placement assistance.

For candidates interested in other technology paths, VibrantMinds also publishes training in Software Testing, Core Java and Python/Data Science-oriented areas, allowing learners to choose a path based on their intended career direction.

The most important thing is to stop treating coding as something you only study before an interview.

Code regularly.

Debug your mistakes.

Understand why your solution works.

Learn how to improve it.

Build applications with what you learn.

And when an interviewer asks you to solve a problem, focus less on remembering a perfect answer and more on showing how you think.

That is the real purpose of Java coding practice for freshers in 2026.

Sep 23, 2026

What Should a Java Fresher Know Before Applying for IT Jobs in 2026? Complete Skills, Coding, SQL & Spring Boot Checklist

Sep 23, 2026

What Should a Java Fresher Know Before Applying for IT Jobs in 2026? Complete Skills, Coding, SQL & Spring Boot Checklist

Sep 23, 2026

Java Coding Questions for Freshers in 2026:

Sep 23, 2026

Java Coding Questions for Freshers in 2026:

Sep 22, 2026

Java Full Stack Developer Projects for Freshers in 2026:

Sep 22, 2026

Related articles

What Should a Java Fresher Know Before Applying for IT Jobs in 2026? Complete Skills, Coding, SQL & Spring Boot Checklist

What Should a Java Fresher Know Before Applying for IT Jobs in 2026? Complete Skills, Coding, SQL & Spring Boot Checklist

Java Coding Questions for Freshers in 2026:

Java Coding Questions for Freshers in 2026:

Java Full Stack Developer Projects for Freshers in 2026:

Java Full Stack Developer Projects for Freshers in 2026: