Basic Java Exercise for Beginners: 60+ Coding Problems with Solutions

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter first number: ");
        int a = sc.nextInt();

        System.out.print("Enter second number: ");
        int b = sc.nextInt();

        int sum = a + b;
        System.out.println("Sum = " + sum);
    }
}Code language: Java (java)

Explanation:

• import java.util.Scanner: This imports the Scanner class, which allows the program to read input from the keyboard.
• sc.nextInt(): Reads the next integer the user types and stores it in the variable.
• int sum = a + b: Adds the two integers together and stores the result in a new variable called sum.
• System.out.println("Sum = " + sum): Prints the result to the console with a descriptive label.

public class Main {
    public static void main(String[] args) {
        int a = 5, b = 10;

        System.out.println("Before swap: a = " + a + ", b = " + b);

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

        System.out.println("After swap:  a = " + a + ", b = " + b);
    }
}Code language: Java (java)

Explanation:

• int temp = a: The original value of a is saved in temp so it is not lost in the next step.
• a = b: The value of b is copied into a, overwriting its original value.
• b = temp: The original value of a, which was safely stored in temp, is now assigned to b, completing the swap.

public class Main {
    public static void main(String[] args) {
        int a = 5, b = 10;

        System.out.println("Before swap: a = " + a + ", b = " + b);

        a = a + b; // a = 15
        b = a - b; // b = 5  (original a)
        a = a - b; // a = 10 (original b)

        System.out.println("After swap:  a = " + a + ", b = " + b);
    }
}Code language: Java (java)

Explanation:

• a = a + b: a now holds the combined sum of both original values (15). The original value of a is encoded inside this sum.
• b = a - b: Subtracting the current b from the sum extracts the original value of a (15 – 10 = 5) and assigns it to b.
• a = a - b: Subtracting the newly updated b from a extracts the original value of b (15 – 5 = 10) and assigns it to a, completing the swap.

public class Main {
    public static void main(String[] args) {
        int length = 8;
        int width  = 5;

        int area      = length * width;
        int perimeter = 2 * (length + width);

        System.out.println("Area      = " + area);
        System.out.println("Perimeter = " + perimeter);
    }
}Code language: Java (java)

Explanation:

• int area = length * width: Multiplies the two dimensions to get the total surface enclosed by the rectangle.
• int perimeter = 2 * (length + width): Adds the length and width first (getting one pair of sides), then doubles it to account for all four sides.
• Both results are printed on separate lines with aligned labels for clarity.

public class Main {
    public static void main(String[] args) {
        double principal = 1000.0;
        double rate      = 5.0;
        int    time      = 3;

        double si = (principal * rate * time) / 100;

        System.out.println("Simple Interest = " + si);
    }
}Code language: Java (java)

Explanation:

• double principal = 1000.0: Declares the starting amount as a decimal-capable type to avoid integer division errors.
• (principal * rate * time) / 100: Applies the standard simple interest formula. The division by 100 converts the percentage rate into a decimal fraction before multiplying.
• System.out.println("Simple Interest = " + si): Prints the calculated interest with a clear label.

public class Main {
    public static void main(String[] args) {
        double principal = 1000.0;
        double rate      = 5.0;
        int    time      = 3;

        double amount = principal * Math.pow((1 + rate / 100), time);
        double ci     = amount - principal;

        System.out.println("Amount after interest = " + amount);
        System.out.println("Compound Interest     = " + ci);
    }
}Code language: Java (java)

Explanation:

• rate / 100: Converts the percentage rate (5.0) into its decimal equivalent (0.05) for use in the formula.
• Math.pow(base, exponent): A built-in Java method that raises the base to the power of the exponent, used here to apply compounding over each year.
• double ci = amount - principal: Isolates just the interest earned by subtracting the original principal from the total accumulated amount.

public class Main {
    public static void main(String[] args) {
        int num = 4;

        int square = num * num;
        int cube   = num * num * num;

        System.out.println("Square of " + num + " = " + square);
        System.out.println("Cube of "   + num + " = " + cube);
    }
}Code language: Java (java)

Explanation:

• int square = num * num: Multiplies the number by itself once to produce the second power (4 x 4 = 16).
• int cube = num * num * num: Multiplies the number by itself twice more to produce the third power (4 x 4 x 4 = 64).
• Both values are printed with the original number embedded in the label so the output is self-explanatory.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int num = 7;

        if (num % 2 == 0) {
            System.out.println(num + " is Even");
        } else {
            System.out.println(num + " is Odd");
        }
    }
}Code language: Java (java)

Explanation:

• num % 2: The modulo operator returns the remainder after dividing num by 2. A result of 0 means there is no remainder, so the number is even.
• if (num % 2 == 0): The condition evaluates to true for even numbers, routing execution to the first print statement.
• else: If the condition is false (remainder is 1), execution falls through to the second print statement, labelling the number as odd.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int a = 14, b = 37, c = 22;

        if (a >= b && a >= c) {
            System.out.println("Largest = " + a);
        } else if (b >= a && b >= c) {
            System.out.println("Largest = " + b);
        } else {
            System.out.println("Largest = " + c);
        }
    }
}Code language: Java (java)

Explanation:

• a >= b && a >= c: Both comparisons must be true at the same time for a to be the largest. The && operator ensures both conditions are checked together.
• else if (b >= a && b >= c): Only reached if a is not the largest. It then checks whether b wins the comparison against both remaining values.
• else: If neither a nor b passed their checks, c must be the largest, so it is printed without any further condition needed.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int year = 2024;

        boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

        if (isLeap) {
            System.out.println(year + " is a Leap Year");
        } else {
            System.out.println(year + " is not a Leap Year");
        }
    }
}Code language: Java (java)

Explanation:

• year % 4 == 0 && year % 100 != 0: Catches ordinary leap years – divisible by 4 but not a century year (e.g., 2024).
• year % 400 == 0: The exception for century years – 400, 800, and 2000 are leap years even though they are divisible by 100.
• boolean isLeap: Storing the result in a named boolean variable makes the if statement cleaner and the logic easier to read at a glance.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter first number:  ");
        double a = sc.nextDouble();

        System.out.print("Enter second number: ");
        double b = sc.nextDouble();

        System.out.print("Enter operator (+, -, *, /): ");
        char op = sc.next().charAt(0);

        double result;

        switch (op) {
            case '+': result = a + b; break;
            case '-': result = a - b; break;
            case '*': result = a * b; break;
            case '/':
                if (b != 0) {
                    result = a / b;
                } else {
                    System.out.println("Error: Division by zero.");
                    return;
                }
                break;
            default:
                System.out.println("Error: Unknown operator.");
                return;
        }

        System.out.println("Result = " + result);
    }
}Code language: Java (java)

Explanation:

• sc.next().charAt(0): Reads the next token from input as a String, then extracts only its first character as a char for use in the switch.
• switch (op): Compares the operator character against each case label in order. When a match is found, that block runs and break exits the switch.
• if (b != 0) inside the division case: Guards against dividing by zero, which would cause a runtime error. The program exits early with an error message if b is zero.
• default: Catches any character that does not match the four valid operators, giving the user meaningful feedback instead of silently producing a wrong answer.

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            System.out.print(i + " ");
        }
    }
}Code language: Java (java)

Explanation:

• int i = 1: The loop variable is initialised to 1, which is the first number to print.
• i <= 100: The loop continues running as long as this condition is true. Once i becomes 101, the condition fails and the loop stops.
• i++: After each iteration, i is incremented by 1, advancing to the next number.
• System.out.print(i + " "): Prints the current number followed by a space, without moving to a new line, so all 100 numbers appear on the same line.

Solution:

public class Main {
    public static void main(String[] args) {
        int n = 10;
        int sum = 0;
        int i = 1;

        while (i <= n) {
            sum += i;
            i++;
        }

        System.out.println("Sum = " + sum);
    }
}Code language: Java (java)

Explanation:

• int sum = 0: Initializes a variable to store the running total before the loop starts.
• while (i <= n): Repeats the loop as long as the counter i is less than or equal to n.
• sum += i: Adds the current value of i to sum on every iteration.
• i++: Increments the counter so the loop eventually terminates, avoiding an infinite loop.

Solution:

public class Main {
    public static void main(String[] args) {
        int n = 20;

        for (int i = 1; i <= n; i++) {
            if (i % 3 != 0 && i % 5 != 0) {
                continue;
            }
            System.out.println(i);
        }
    }
}Code language: Java (java)

Explanation:

• i % 3 != 0 && i % 5 != 0: Checks whether the number is divisible by neither 3 nor 5.
• continue: Skips the rest of the current iteration and moves to the next value of i without printing.
• System.out.println(i): Runs only when the number passes the divisibility check, printing it to the console.

Solution:

public class Main {
    public static void main(String[] args) {
        int n = 10;
        int i = 1;

        do {
            if (i % 2 == 0) {
                System.out.println(i);
            }
            i++;
        } while (i <= n);
    }
}Code language: Java (java)

Explanation:

• do { ... } while (i <= n): Executes the loop body first, then checks the condition, guaranteeing at least one run.
• i % 2 == 0: Checks whether the current number is even by testing if it leaves no remainder when divided by 2.
• i++: Increments the counter before the condition is re-checked at the end of the loop.

public class Main {
    public static void main(String[] args) {
        int num = 7;
        for (int i = 1; i <= 10; i++) {
            int product = num * i;
            System.out.println(num + " x " + i + " = " + product);
        }
    }
}Code language: Java (java)

Explanation:

• for (int i = 1; i <= 10; i++): The loop runs exactly 10 times, with i taking the values 1 through 10 – one for each row of the table.
• int product = num * i: On every iteration, the target number is multiplied by the current value of the loop counter to produce the result for that row.
• System.out.println(...): Prints each row of the table as a formatted equation, moving to a new line after each one.

public class Main {
    public static void main(String[] args) {
        int n = 6;
        long factorial = 1;
        for (int i = 1; i <= n; i++) {
            factorial *= i;
        }
        System.out.println("Factorial of " + n + " = " + factorial);
    }
}Code language: Java (java)

Explanation:

• long factorial = 1: long is used instead of int because factorials grow very quickly – 13! already exceeds the maximum value of an int.
• factorial *= i: A shorthand for factorial = factorial * i. On each iteration, the running product is multiplied by the next integer in the sequence.
• After the loop finishes, factorial holds the product of all integers from 1 to n, which is the definition of n factorial (n!).

public class Main {
    public static void main(String[] args) {
        int n = 8;
        int a = 0, b = 1;
        for (int i = 0; i < n; i++) {
            System.out.print(a + " ");
            int next = a + b;
            a = b;
            b = next;
        }
    }
}Code language: Java (java)

Explanation:

• int a = 0, b = 1: These two variables represent the current and next term of the sequence. The series always starts with 0 and 1.
• int next = a + b: The sum of the two current terms gives the next term in the series. It is stored in a temporary variable before either a or b is overwritten.
• a = b; b = next: Both variables slide forward by one position: a takes the old value of b, and b takes the newly computed next term, ready for the following iteration.

public class Main {
    public static void main(String[] args) {
        int num = 4892;

        int reversed = 0;

        while (num != 0) {
            int digit = num % 10;
            reversed  = reversed * 10 + digit;
            num      /= 10;
        }

        System.out.println("Reversed = " + reversed);
    }
}Code language: Java (java)

Explanation:

• int digit = num % 10: The modulo operation extracts the rightmost digit of the current number. For 4892, the first digit extracted is 2.
• reversed = reversed * 10 + digit: Shifts all previously collected digits one place to the left (by multiplying by 10) and appends the newly extracted digit on the right, building the reversed number from left to right.
• num /= 10: Integer division drops the last digit from num. The loop continues until num reaches 0, meaning all digits have been processed.

public class Main {
    public static void main(String[] args) {
        int num = 4931;

        int sum = 0;

        while (num != 0) {
            sum += num % 10;
            num /= 10;
        }

        System.out.println("Sum of digits = " + sum);
    }
}Code language: Java (java)

Explanation:

• int sum = 0: The accumulator starts at zero so that the first digit added gives the correct running total.
• sum += num % 10: Extracts the last digit with % 10 and immediately adds it to the running sum in a single step.
• num /= 10: Drops the digit that was just processed by performing integer division, shrinking the number by one digit each iteration until nothing remains.

public class Main {
    public static void main(String[] args) {
        int num = 29;
        boolean isPrime = true;
        if (num < 2) {
            isPrime = false;
        } else {
            for (int i = 2; i <= num / 2; i++) {
                if (num % i == 0) {
                    isPrime = false;
                    break;
                }
            }
        }
        if (isPrime) {
            System.out.println(num + " is a Prime Number");
        } else {
            System.out.println(num + " is not a Prime Number");
        }
    }
}Code language: Java (java)

Explanation:

• if (num < 2): Numbers less than 2 (including 0 and 1) are never prime by definition, so the flag is set to false immediately without entering the loop.
• i <= num / 2: No divisor of a number can be larger than half of it (other than the number itself), so the loop only needs to check up to that point, saving unnecessary iterations.
• num % i == 0: If the remainder is zero, i divides num evenly, which means num has a factor other than 1 and itself – so it cannot be prime.
• break: As soon as one divisor is found, there is no need to keep checking. break exits the loop early, making the program more efficient.

public class Main {
    public static void main(String[] args) {
        int num = 153;

        int digits = String.valueOf(num).length();
        int sum    = 0;
        int temp   = num;

        while (temp != 0) {
            int digit = temp % 10;
            sum      += (int) Math.pow(digit, digits);
            temp     /= 10;
        }

        if (sum == num) {
            System.out.println(num + " is an Armstrong Number");
        } else {
            System.out.println(num + " is not an Armstrong Number");
        }
    }
}Code language: Java (java)

Explanation:

• String.valueOf(num).length(): Converts the number to its string representation and measures its length to determine how many digits it has – this count is used as the exponent.
• int temp = num: A copy of the original number is used for digit extraction so the original value of num is preserved for the final comparison.
• Math.pow(digit, digits): Raises each extracted digit to the power equal to the total number of digits (3 for a 3-digit number, 4 for a 4-digit number, and so on).
• sum == num: If the accumulated sum of powered digits matches the original number exactly, the number is Armstrong.

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter number of rows: ");
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}Code language: Java (java)

Explanation:

• for (int i = 1; i <= n; i++): The outer loop runs once for each row. The variable i represents both the current row number and the number of stars that row should contain.
• for (int j = 1; j <= i; j++): The inner loop runs i times per row, printing one star per iteration. Because the upper limit of the inner loop is i, each row gets exactly one more star than the previous one.
• System.out.println(): Called after the inner loop finishes each row, this moves the cursor to the next line so the next row starts fresh below.

public class Main {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        // Using a standard for loop
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println(); // move to next line
        // Using an enhanced for-each loop
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}Code language: Java (java)

Explanation:

• int[] arr = {10, 20, 30, 40, 50}: Declares an integer array and initializes it with five values in one line using an array initializer block.
• arr.length: A built-in property that returns the number of elements in the array. Using it instead of a hardcoded number means the loop still works correctly if the array is later changed to have more or fewer elements.
• arr[i]: Accesses the element at position i. Array indices in Java start at 0, so the first element is arr[0] and the last is arr[arr.length - 1].
• for (int num : arr): The enhanced for-each loop is a cleaner alternative when you only need the values and do not need the index. It reads as “for each integer num in arr“.

public class Main {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};

        int sum = 0;

        for (int num : arr) {
            sum += num;
        }

        double average = (double) sum / arr.length;

        System.out.println("Sum     = " + sum);
        System.out.println("Average = " + average);
    }
}Code language: Java (java)

Explanation:

• int sum = 0: The accumulator starts at zero. Each element from the array is added to it during the loop, building up the total progressively.
• sum += num: Shorthand for sum = sum + num. On each iteration, the current element is folded into the running total.
• (double) sum / arr.length: Without the cast, dividing two integers in Java performs integer division and discards any decimal remainder. Casting sum to double first forces floating-point division, giving an accurate average.

public class Main {
    public static void main(String[] args) {
        int[] arr = {34, 7, 23, 89, 12, 55};
        int min = arr[0];
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) min = arr[i];
            if (arr[i] > max) max = arr[i];
        }
        System.out.println("Minimum = " + min);
        System.out.println("Maximum = " + max);
    }
}Code language: Java (java)

Explanation:

• int min = arr[0]; int max = arr[0]: Both trackers are seeded with the first element. This guarantees they hold a valid array value before any comparisons begin, and the loop then starts from index 1 since index 0 is already accounted for.
• if (arr[i] < min) min = arr[i]: Each element is compared to the current minimum. If a smaller value is found, it becomes the new minimum.
• if (arr[i] > max) max = arr[i]: The same pattern applies for the maximum. Both checks run independently on every element, so a single pass through the array is all that is needed.

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int left  = 0;
        int right = arr.length - 1;
        while (left < right) {
            int temp    = arr[left];
            arr[left]   = arr[right];
            arr[right]  = temp;
            left++;
            right--;
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}Code language: Java (java)

Explanation:

• int left = 0; int right = arr.length - 1: Two pointers start at opposite ends of the array. They will work their way toward the center, one swap at a time.
• int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp: The standard three-step swap (from Exercise 2) exchanges the elements at the two pointer positions without losing either value.
• left++; right--: After each swap, both pointers move one step inward. The loop stops when they meet or cross, at which point every outer pair has been swapped and the array is reversed.

public class Main {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        int   n   = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp    = arr[j];
                    arr[j]      = arr[j + 1];
                    arr[j + 1]  = temp;
                }
            }
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}Code language: Java (java)

Explanation:

• for (int i = 0; i < n - 1; i++): The outer loop controls the number of passes. Each pass guarantees that at least one more element has settled into its final sorted position at the end of the array.
• j < n - 1 - i: The inner loop shrinks with each pass of the outer loop. Since the last i elements are already sorted and in place, there is no need to compare them again.
• if (arr[j] > arr[j + 1]): Compares each element with its immediate neighbour. If they are out of order, they are swapped – this is the “bubble” step that pushes larger values rightward on each pass.

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 3, 4, 2, 3, 5, 4, 6};
        System.out.println("Duplicates found:");
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] == arr[j]) {
                    System.out.println("Duplicate found: " + arr[i]);
                    break;
                }
            }
        }
    }
}Code language: Java (java)

Explanation:

• for (int i = 0; i < arr.length - 1; i++): The outer loop visits every element except the last one, since a duplicate must have a matching partner somewhere later in the array.
• for (int j = i + 1; j < arr.length; j++): The inner loop starts just after the current outer index. This avoids comparing an element with itself and avoids checking pairs that have already been examined.
• if (arr[i] == arr[j]): A match means the value at position i appears at least once more later in the array – it is a duplicate.
• break: Exits the inner loop as soon as the first match for arr[i] is found, preventing the same value from being reported multiple times if it appears three or more times in the array.

public class Main {
    public static void main(String[] args) {
        int[] arr1   = {1, 2, 3};
        int[] arr2   = {4, 5, 6};
        int[] merged = new int[arr1.length + arr2.length];
        for (int i = 0; i < arr1.length; i++) {
            merged[i] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++) {
            merged[arr1.length + i] = arr2[i];
        }
        for (int num : merged) {
            System.out.print(num + " ");
        }
    }
}Code language: Java (java)

Explanation:

• new int[arr1.length + arr2.length]: Allocates a new array large enough to hold every element from both source arrays, with no wasted space and no risk of running short.
• merged[i] = arr1[i]: The first loop copies all elements from arr1 into the beginning of the merged array, occupying positions 0 through arr1.length - 1.
• merged[arr1.length + i] = arr2[i]: The second loop places each element of arr2 immediately after the last element of arr1 by offsetting the destination index by arr1.length.

public class Main {
    public static void main(String[] args) {
        int[][] A = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] B = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
        int[][] C = new int[3][3];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                C[i][j] = A[i][j] + B[i][j];
            }
        }
        System.out.println("Result:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(C[i][j] + " ");
            }
            System.out.println();
        }
    }
}Code language: Java (java)

Explanation:

• int[][] C = new int[3][3]: Declares an empty 3×3 result matrix. Java automatically fills it with zeros until values are assigned, so no manual initialisation is needed.
• C[i][j] = A[i][j] + B[i][j]: The two indices i and j act as the row and column coordinates respectively. Adding the values at the same coordinates in both matrices and storing them in the result matrix is exactly what matrix addition means mathematically.
• System.out.println() after the inner loop: Moves the cursor to the next line after each row is printed, so the output displays as a grid rather than a flat sequence of numbers.

public class Main {
    public static void main(String[] args) {
        String str   = "Hello, World!";
        int    count = 0;

        for (char c : str.toCharArray()) {
            count++;
        }

        System.out.println("Length = " + count);
    }
}Code language: Java (java)

Explanation:

• str.toCharArray(): Converts the string into an array of char values, with one entry per character including spaces and punctuation, making it possible to loop through each one individually.
• for (char c : str.toCharArray()): The for-each loop visits every character in order. The variable c holds the current character, though in this exercise its value is not used – only the fact that we visited it matters.
• count++: Increments the counter by 1 for each character visited. After all characters have been processed, count holds the total length of the string.

public class Main {
    public static void main(String[] args) {
        String str      = "Racecar";
        String lower    = str.toLowerCase();
        boolean isPalin = true;
        int left  = 0;
        int right = lower.length() - 1;
        while (left < right) {
            if (lower.charAt(left) != lower.charAt(right)) {
                isPalin = false;
                break;
            }
            left++;
            right--;
        }
        if (isPalin) {
            System.out.println("\"" + str + "\" is a Palindrome");
        } else {
            System.out.println("\"" + str + "\" is not a Palindrome");
        }
    }
}Code language: Java (java)

Explanation:

• str.toLowerCase(): Creates a new lowercase copy of the string for comparison purposes. The original str is preserved so it can be printed with its original casing in the output message.
• lower.charAt(left) != lower.charAt(right): Compares the characters at the outermost unvisited positions. If they differ at any point, the string cannot be a palindrome and the loop exits early.
• left++; right--: Moves both pointers one step inward after a successful match, exactly as in the Reverse Array exercise. The loop ends when the pointers meet, meaning every symmetric pair has been verified.

public class Main {
    public static void main(String[] args) {
        String str       = "Hello, World!";
        String uppercase = str.toUpperCase();
        String lowercase = str.toLowerCase();

        System.out.println("Uppercase: " + uppercase);
        System.out.println("Lowercase: " + lowercase);
    }
}Code language: Java (java)

Explanation:

• str.toUpperCase(): Returns a new string where every lowercase letter has been converted to its uppercase equivalent. Non-letter characters such as spaces, commas, and exclamation marks are left unchanged.
• str.toLowerCase(): Returns another new string where every uppercase letter is converted to lowercase. Again, non-letter characters are unaffected.
• Immutability of strings: After calling both methods, the original variable str still holds "Hello, World!" unchanged. In Java, String objects can never be modified in place – every method that appears to change a string actually returns a new one.

public class Main {
    public static void main(String[] args) {
        String        str    = "Hello, World! How are you?";
        StringBuilder result = new StringBuilder();

        for (char c : str.toCharArray()) {
            if (c != ' ') {
                result.append(c);
            }
        }

        System.out.println(result.toString());
    }
}Code language: Java (java)

Explanation:

• StringBuilder result = new StringBuilder(): Creates a mutable sequence of characters. Unlike a regular String, a StringBuilder can be modified in place, making it the right tool for building a string incrementally inside a loop.
• if (c != ' '): The condition filters out space characters. Every other character, including punctuation and letters, passes through and is added to the result.
• result.append(c): Adds the current character to the end of the StringBuilder buffer without creating a new object each time, which is far more efficient than string concatenation with + in a loop.
• result.toString(): Converts the finished StringBuilder back into a regular String for printing.

public class Main {
    public static void main(String[] args) {
        String str  = "hello";
        int[]  freq = new int[256];

        for (char c : str.toCharArray()) {
            freq[c]++;
        }

        for (char c : str.toCharArray()) {
            if (freq[c] > 0) {
                System.out.println(c + ": " + freq[c]);
                freq[c] = 0; // mark as printed
            }
        }
    }
}Code language: Java (java)

Explanation:

• int[] freq = new int[256]: Creates a frequency table with 256 slots, one for each standard ASCII character. Java initialises all slots to zero automatically.
• freq[c]++: In Java, a char can be used directly as an integer index because each character has a numeric ASCII code. For example, 'h' has the code 104, so freq[104] is incremented when 'h' is encountered.
• if (freq[c] > 0): Only prints characters that were actually found in the string. After printing, the slot is reset to 0 so that characters appearing more than once (like 'l') are not printed a second time on the next encounter.

Solution:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String str1 = "listen";
        String str2 = "silent";

        char[] arr1 = str1.toLowerCase().toCharArray();
        char[] arr2 = str2.toLowerCase().toCharArray();

        Arrays.sort(arr1);
        Arrays.sort(arr2);

        if (Arrays.equals(arr1, arr2)) {
            System.out.println("\"" + str1 + "\" and \"" + str2 + "\" are anagrams");
        } else {
            System.out.println("\"" + str1 + "\" and \"" + str2 + "\" are not anagrams");
        }
    }
}Code language: Java (java)

Explanation:

• toCharArray(): Converts each string into an array of individual characters for comparison.
• Arrays.sort(arr1): Sorts the characters alphabetically so both arrays can be compared position by position.
• Arrays.equals(arr1, arr2): Returns true only if both arrays have the same characters in the same order after sorting.

public class Main {

    public static boolean isEven(int number) {
        return number % 2 == 0;
    }

    public static void main(String[] args) {
        int a = 4;
        int b = 7;

        System.out.println(a + " is even: " + isEven(a));
        System.out.println(b + " is even: " + isEven(b));
    }
}Code language: Java (java)

Explanation:

• public static boolean isEven(int number): The method signature declares that this method is accessible from anywhere (public), belongs to the class rather than an instance (static), returns a boolean value, and accepts one integer parameter named number.
• return number % 2 == 0: The expression number % 2 == 0 evaluates to either true or false, and that boolean is returned directly to wherever the method was called from – no intermediate variable needed.
• isEven(a) inside println: The method call is used directly inside the print statement. Java evaluates isEven(a) first, gets back a boolean, and then concatenates it into the output string.

class Student {
    String name;
    int    rollNumber;

    void displayInfo() {
        System.out.println("Student Name:        " + name);
        System.out.println("Student Roll Number: " + rollNumber);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s    = new Student();
        s.name       = "Alice";
        s.rollNumber = 101;

        s.displayInfo();
    }
}Code language: Java (java)

Explanation:

• class Student: Defines a blueprint that describes what data a student holds (name, rollNumber) and what it can do (displayInfo()). No memory is allocated yet at this point – the class is just a template.
• Student s = new Student(): The new keyword allocates memory for a real object based on the Student blueprint and returns a reference to it, stored in the variable s.
• s.name = "Alice": Dot notation accesses the field named name on the specific object referred to by s, and assigns a value to it.
• s.displayInfo(): Calls the method on the object s. Inside the method, name and rollNumber automatically refer to the values belonging to s, not to any other student object.

class Book {
    String title;
    String author;

    Book(String title, String author) {
        this.title  = title;
        this.author = author;
    }

    void displayInfo() {
        System.out.println("Title: " + title + "  |  Author: " + author);
    }
}

public class Main {
    public static void main(String[] args) {
        Book b1 = new Book("1984", "George Orwell");
        Book b2 = new Book("Dune", "Frank Herbert");

        b1.displayInfo();
        b2.displayInfo();
    }
}Code language: Java (java)

Explanation:

• Book(String title, String author): This is the constructor. It is called automatically by Java the moment new Book(...) is executed, allowing the object to be fully initialised in a single step.
• this.title = title: The keyword this refers to the current object being constructed. It is used here to distinguish between the field named title (belonging to the object) and the parameter also named title (local to the constructor).
• new Book("1984", "George Orwell"): The arguments passed to new are forwarded directly into the constructor parameters, so the object arrives fully initialised – no separate assignment steps needed.

public class Main {

    // Area of a square
    public static int calculateArea(int side) {
        return side * side;
    }

    // Area of a rectangle
    public static int calculateArea(int length, int width) {
        return length * width;
    }

    public static void main(String[] args) {
        System.out.println("Area of square    = " + calculateArea(5));
        System.out.println("Area of rectangle = " + calculateArea(8, 3));
    }
}Code language: Java (java)

Explanation:

• Two methods named calculateArea: Java allows this because their parameter lists are different – one takes a single int, the other takes two. The combination of method name and parameter list is called the method’s signature, and each overload must have a unique signature.
• calculateArea(5): Java sees one argument and matches it to the single-parameter version, computing 5 * 5 = 25.
• calculateArea(8, 3): Java sees two arguments and selects the two-parameter version, computing 8 * 3 = 24. This selection happens at compile time, not at runtime.

class BankAccount {
    private double balance;
    // Setter
    public void setBalance(double amount) {
        if (amount >= 0) {
            balance = amount;
        }
    }
    // Getter
    public double getBalance() {
        return balance;
    }
    // Deposit
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("After deposit:   " + balance);
        }
    }
    // Withdraw
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("After withdraw:  " + balance);
        } else {
            System.out.println("Insufficient funds.");
        }
    }
}
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.setBalance(1000);
        System.out.println("Initial balance: " + account.getBalance());
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Current balance: " + account.getBalance());
    }
}Code language: Java (java)

Explanation:

• private double balance: The private keyword means no code outside the BankAccount class can read or write this field directly. Any attempt to write account.balance = -500 from main would cause a compile error.
• getBalance() and setBalance(): These are the getter and setter methods – the controlled gates through which outside code can read and write the balance. The setter includes a guard (amount >= 0) that prevents the balance from being set to a negative value, something that would be impossible to enforce if the field were public.
• withdraw(double amount): The guard condition amount <= balance ensures a withdrawal can never push the balance below zero. This business rule lives inside the class where it belongs – the caller in main does not need to remember to check it.
• Encapsulation in practice: By making balance private and routing all changes through methods, the class guarantees its own data stays valid no matter how it is used from outside. This is the core promise of encapsulation.

Solution:

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.bark();
    }
}Code language: Java (java)

Explanation:

• class Dog extends Animal: Establishes an inheritance relationship, making Dog a subclass that automatically inherits all accessible members of Animal.
• dog.eat(): Calls the inherited method from the Animal class, even though Dog never defines it directly.
• dog.bark(): Calls the method defined directly in the Dog subclass.

Solution:

class Shape {
    void draw() {
        System.out.println("Drawing a shape.");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
    }
}Code language: Java (java)

Explanation:

• @Override: Indicates that the method in Circle is intentionally replacing the version defined in Shape, and helps the compiler catch mistakes.
• Shape shape = new Circle(): Declares a reference of type Shape but points it to a Circle object, a valid use of polymorphism.
• shape.draw(): Even though the reference type is Shape, Java calls the overridden version in Circle at runtime, based on the actual object type.

Solution:

class Counter {
    static int count = 0;

    Counter() {
        count++;
    }

    static int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

        System.out.println("Total Counters Created = " + Counter.getCount());
    }
}Code language: Java (java)

Explanation:

• static int count = 0: Declares a variable shared by all instances of Counter rather than a separate copy for each object.
• count++ inside the constructor: Increments the shared counter every time a new Counter object is created.
• static int getCount(): A static method that can be called on the class itself (Counter.getCount()) without needing an object instance.

Solution:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);
        numbers.add(50);

        System.out.println(numbers);
    }
}Code language: Java (java)

Explanation:

• new ArrayList<Integer>(): Creates an empty resizable list that can hold Integer values.
• numbers.add(10): Appends an element to the end of the ArrayList.
• System.out.println(numbers): Automatically calls the ArrayList’s built-in toString() method to print all elements in bracket notation.

Solution:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Mango");
        fruits.add("Orange");

        fruits.remove("Banana");
        boolean hasMango = fruits.contains("Mango");

        System.out.println("After Removal: " + fruits);
        System.out.println("Contains Mango: " + hasMango);
    }
}Code language: Java (java)

Explanation:

• fruits.remove("Banana"): Removes the first occurrence of the specified element from the list.
• fruits.contains("Mango"): Returns true if the list contains the given element, false otherwise.
• "After Removal: " + fruits: Concatenates the string label with the ArrayList’s printable representation.

Solution:

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Charlie");
        names.add("Alice");
        names.add("Bob");
        names.add("David");

        Collections.sort(names);

        System.out.println(names);
    }
}Code language: Java (java)

Explanation:

• Collections.sort(names): Sorts the ArrayList in place using the natural ordering of its elements, which for String means alphabetical order.
• System.out.println(names): Prints the sorted list using its default bracket-notation format.

Solution:

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

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> marks = new HashMap<>();
        marks.put("Alice", 85);
        marks.put("Bob", 92);
        marks.put("Charlie", 78);

        for (Map.Entry<String, Integer> entry : marks.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}Code language: Java (java)

Explanation:

• marks.put("Alice", 85): Inserts a key-value pair into the HashMap, using the student name as the key and the mark as the value.
• marks.entrySet(): Returns a set view of all key-value pairs stored in the map.
• entry.getKey() / entry.getValue(): Retrieves the key and value from each Map.Entry object during iteration.
• Note: HashMap does not guarantee any specific order, so the printed order of entries may differ from the insertion order.

Solution:

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

public class Main {
    public static void main(String[] args) {
        String sentence = "the quick brown fox jumps over the lazy dog the fox runs";
        String[] words = sentence.split(" ");

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

        for (String word : words) {
            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : wordCount.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}Code language: Java (java)

Explanation:

• sentence.split(" "): Splits the sentence into an array of individual words using a space as the delimiter.
• wordCount.getOrDefault(word, 0): Returns the current count for the word, or 0 if the word has not been seen before, avoiding a null pointer exception.
• wordCount.put(word, ... + 1): Updates the map with the incremented count for that word.
• Note: HashMap does not guarantee insertion order, so the output order of words may vary.

Solution:

import java.util.ArrayList;
import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(10);
        numbers.add(30);
        numbers.add(20);
        numbers.add(40);

        LinkedHashSet<Integer> uniqueSet = new LinkedHashSet<>(numbers);
        numbers.clear();
        numbers.addAll(uniqueSet);

        System.out.println(numbers);
    }
}Code language: Java (java)

Explanation:

• new LinkedHashSet<Integer>(numbers): Creates a LinkedHashSet from the ArrayList, which automatically removes duplicates while preserving the order elements first appeared in.
• numbers.clear(): Empties the original ArrayList so it can be repopulated with unique values.
• numbers.addAll(uniqueSet): Copies all unique elements from the LinkedHashSet back into the ArrayList.

Solution:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 85);
        scores.put("Bob", 60);
        scores.put("Charlie", 92);
        scores.put("David", 75);

        List<Map.Entry<String, Integer>> entryList = new ArrayList<>(scores.entrySet());
        entryList.sort(Map.Entry.comparingByValue());

        for (Map.Entry<String, Integer> entry : entryList) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}Code language: Java (java)

Explanation:

• new ArrayList<>(scores.entrySet()): Copies the HashMap’s entries into a List so they can be sorted, since HashMap itself has no defined order.
• entryList.sort(Map.Entry.comparingByValue()): Sorts the list of entries in ascending order based on their values using a built-in comparator.
• entry.getKey() / entry.getValue(): Reads the name and score from each sorted entry for printing.

Solution:

import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap<String, Integer> products = new TreeMap<>();
        products.put("Banana", 40);
        products.put("Apple", 120);
        products.put("Mango", 90);
        products.put("Cherry", 200);

        for (Map.Entry<String, Integer> entry : products.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}Code language: Java (java)

Explanation:

• new TreeMap<String, Integer>(): Creates a map that automatically sorts its keys in natural ascending order as elements are added.
• products.put("Banana", 40): Inserts each key-value pair; TreeMap places it in the correct sorted position internally.
• products.entrySet(): Returns entries already sorted by key, so no extra sorting step is needed before printing.

Solution:

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> employees = new HashMap<>();
        employees.put(101, "John");
        employees.put(102, "Sara");
        employees.put(103, "Mike");

        int searchKey = 102;

        if (employees.containsKey(searchKey)) {
            System.out.println("Key " + searchKey + " exists with value " + employees.get(searchKey));
        } else {
            System.out.println("Key " + searchKey + " does not exist");
        }
    }
}Code language: Java (java)

Explanation:

• employees.containsKey(searchKey): Returns true if the given key is present in the map, without needing to check for a null value.
• employees.get(searchKey): Retrieves the value associated with the key, called only after confirming the key exists.
• if / else: Prints a different message depending on whether the key was found.

Solution:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 3, 5, 9, 8};

        HashSet<Integer> uniqueNumbers = new HashSet<>();
        for (int num : numbers) {
            uniqueNumbers.add(num);
        }

        System.out.println(uniqueNumbers);
    }
}Code language: Java (java)

Explanation:

• new HashSet<Integer>(): Creates an empty set that automatically rejects duplicate values.
• uniqueNumbers.add(num): Adds each array element to the set; duplicate values are silently ignored.
• Note: HashSet does not guarantee any particular order, so the printed order of elements may vary.

Solution:

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {45, 12, 78, 12, 3, 45, 56};

        TreeSet<Integer> uniqueSorted = new TreeSet<>();
        for (int num : numbers) {
            uniqueSorted.add(num);
        }

        System.out.println(uniqueSorted);
    }
}Code language: Java (java)

Explanation:

• new TreeSet<Integer>(): Creates a set that keeps its elements sorted in ascending order and automatically removes duplicates.
• uniqueSorted.add(num): Adds each number; duplicates are ignored and unique values are inserted in their correct sorted position.
• System.out.println(uniqueSorted): Prints the elements already sorted, requiring no additional sorting step.

Solution:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {3, 4, 5, 6, 7};

        HashSet<Integer> set1 = new HashSet<>();
        for (int num : arr1) {
            set1.add(num);
        }

        HashSet<Integer> set2 = new HashSet<>();
        for (int num : arr2) {
            set2.add(num);
        }

        set1.retainAll(set2);

        System.out.println(set1);
    }
}Code language: Java (java)

Explanation:

• set1.retainAll(set2): Modifies set1 so it retains only the elements that are also present in set2, effectively computing the intersection.
• set1.add(num) / set2.add(num): Populates each set from its corresponding array, automatically discarding any duplicate values within the same array.
• System.out.println(set1): Prints the common elements remaining in set1 after the intersection.

Solution:

import java.time.LocalDate;
import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) {
        LocalDate currentDate = LocalDate.now();
        LocalDateTime currentDateTime = LocalDateTime.now();

        System.out.println("Current Date = " + currentDate);
        System.out.println("Current Date and Time = " + currentDateTime);
    }
}Code language: Java (java)

Explanation:

• LocalDate.now(): Returns the current date from the system clock in the default time zone, without time information.
• LocalDateTime.now(): Returns the current date combined with the current time, down to nanosecond precision.
• Note: Since these methods read the live system clock, the printed values will be different each time you run the program.

Solution:

import java.time.LocalDate;
import java.time.Period;

public class Main {
    public static void main(String[] args) {
        LocalDate startDate = LocalDate.of(2015, 6, 15);
        LocalDate endDate = LocalDate.of(2023, 9, 10);

        Period period = Period.between(startDate, endDate);

        System.out.println("Years = " + period.getYears());
        System.out.println("Months = " + period.getMonths());
        System.out.println("Days = " + period.getDays());
    }
}Code language: Java (java)

Explanation:

• LocalDate.of(2015, 6, 15): Creates a LocalDate object representing a specific year, month, and day.
• Period.between(startDate, endDate): Calculates the difference between two dates as a Period object containing years, months, and days.
• period.getYears(): Extracts each component of the calculated period (years, months, days) separately for display.

Solution:

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        LocalDate date = LocalDate.of(2026, 3, 15);

        LocalDate newDateAfterAdding = date.plusDays(10);
        LocalDate newDateAfterSubtracting = date.minusDays(5);

        System.out.println("New Date after Adding = " + newDateAfterAdding);
        System.out.println("New Date after Subtracting = " + newDateAfterSubtracting);
    }
}Code language: Java (java)

Explanation:

• date.plusDays(10): Returns a new LocalDate that is 10 days after the original date.
• date.minusDays(5): Returns a new LocalDate that is 5 days before the original date.
• Immutability: LocalDate never changes in place. Each method call produces a fresh LocalDate instance, leaving the original date unchanged.

Solution:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalDate date = LocalDate.of(2026, 12, 25);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");
        String formattedDate = date.format(formatter);

        System.out.println("Formatted Date = " + formattedDate);
    }
}Code language: Java (java)

Explanation:

• DateTimeFormatter.ofPattern("dd-MM-yyyy"): Creates a formatter that defines how the date should be displayed, day first, then month, then year.
• date.format(formatter): Converts the LocalDate into a String using the given formatter pattern.
• "Formatted Date = " + formattedDate: Concatenates the label with the resulting formatted string for display.

Solution:

import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        String fileName = "output.txt";
        String text = "Hello, this is a sample file.";

        try (FileWriter writer = new FileWriter(fileName)) {
            writer.write(text);
            System.out.println("Data written to the file successfully.");
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the file.");
        }
    }
}Code language: Java (java)

Explanation:

• new FileWriter(fileName): Creates a FileWriter object that opens (or creates) the specified file for writing.
• try (FileWriter writer = ...): Uses try-with-resources so the file is automatically closed once the block finishes.
• writer.write(text): Writes the given string content to the file.
• catch (IOException e): Catches any input/output error, such as an invalid file path, and prevents the program from crashing.

Solution:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        String fileName = "output.txt";

        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("An error occurred while reading the file.");
        }
    }
}Code language: Java (java)

Explanation:

• new BufferedReader(new FileReader(fileName)): Wraps a FileReader inside a BufferedReader to read text efficiently using an internal buffer.
• reader.readLine(): Reads one line of text at a time and returns null when the end of the file is reached.
• while ((line = reader.readLine()) != null): Assigns each line to the variable line and continues looping until there is nothing left to read.
• catch (IOException e): Handles errors such as a missing file or a restricted file path.

Solution:

import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        String fileName = "output.txt";
        String textToAppend = "This line was appended.";

        try (FileWriter writer = new FileWriter(fileName, true)) {
            writer.write(System.lineSeparator() + textToAppend);
            System.out.println("Data appended to the file successfully.");
        } catch (IOException e) {
            System.out.println("An error occurred while appending to the file.");
        }
    }
}Code language: Java (java)

Explanation:

• new FileWriter(fileName, true): The second argument true enables append mode, so existing content in the file is preserved.
• System.lineSeparator() + textToAppend: Adds a new line before the appended text so it does not run into the previous content.
• catch (IOException e): Handles any error that occurs while accessing or writing to the file.