Java Method Exercises: 20+ Coding Problems with Solutions

public class Main {
    public static double calculateArea(double radius) {
        if (radius < 0) {
            return -1.0;
        }
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        double result = calculateArea(5.0);
        System.out.println("Area = " + result);
    }
}Code language: Java (java)

Explanation:

• if (radius < 0): Guards against invalid input before doing any calculation, returning -1.0 as a sentinel value for errors.
• Math.PI * radius * radius: Applies the standard circle area formula using Java's built-in constant for pi.
• Return type double: Ensures the method can return a precise decimal value rather than being rounded to an integer.
• Alternative: You could use Math.pow(radius, 2) instead of radius * radius, though direct multiplication is generally faster for a simple square.

public class Main {
    public static int add(int a, int b) {
        return a + b;
    }

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

    public static double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println("add(2, 3) = " + add(2, 3));
        System.out.println("add(2, 3, 4) = " + add(2, 3, 4));
        System.out.println("add(2.5, 3.5) = " + add(2.5, 3.5));
    }
}Code language: Java (java)

Explanation:

• add(int a, int b) and add(int a, int b, int c): Differ in the number of parameters, so Java treats them as distinct methods.
• add(double a, double b): Differs in parameter type from the two-integer version, letting Java select the correct overload based on the argument types passed in.
• Compile-time resolution: Java determines which overload to call at compile time based on the arguments' types, not at runtime.
• Alternative: You could achieve similar flexibility with a single method using Object... varargs and manual type checking, but overloading is clearer and type-safe.

public class Main {
    public static double computeArea(double radius) {
        return Math.PI * radius * radius;
    }

    public static double computeArea(double length, double width) {
        return length * width;
    }

    public static double computeArea(double base, double height, boolean isTriangle) {
        return 0.5 * base * height;
    }

    public static void main(String[] args) {
        System.out.println("Circle Area = " + computeArea(5.0));
        System.out.println("Rectangle Area = " + computeArea(4.0, 6.0));
        System.out.println("Triangle Area = " + computeArea(4.0, 6.0, true));
    }
}Code language: Java (java)

Explanation:

• computeArea(double radius): Matches calls with exactly one double argument, calculating a circle's area.
• computeArea(double length, double width): Matches calls with two double arguments, calculating a rectangle's area.
• computeArea(double base, double height, boolean isTriangle): Matches calls with two doubles and a boolean, calculating a triangle's area using the base-height formula.
• Alternative: You could rename each method distinctly, like circleArea() and rectangleArea(), for extra clarity, but overloading keeps a consistent API name for related operations.

public class Main {
    public static void printDetails(String name) {
        System.out.println("Name: " + name);
    }

    public static void printDetails(String name, int age) {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void printDetails(String name, int age, String city) {
        System.out.println("Name: " + name + ", Age: " + age + ", City: " + city);
    }

    public static void main(String[] args) {
        printDetails("Alice");
        printDetails("Bob", 25);
        printDetails("Charlie", 30, "New York");
    }
}Code language: Java (java)

Explanation:

• printDetails(String name): Handles calls with only a name, producing the shortest summary.
• printDetails(String name, int age): Handles calls with a name and age, adding the age to the printed output.
• printDetails(String name, int age, String city): Handles calls with all three pieces of information, producing the fullest summary.
• Alternative: You could have the shorter overloads call the longer one with default values, like printDetails(name, 0, "Unknown"), which reduces duplication but requires meaningful defaults.

public class Main {
    public static int search(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }

    public static int search(String[] arr, String target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(target)) {
                return i;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        System.out.println("Index of 30 = " + search(new int[]{10, 20, 30, 40}, 30));
        System.out.println("Index of \"banana\" = " + search(new String[]{"apple", "banana", "cherry"}, "banana"));
    }
}Code language: Java (java)

Explanation:

• search(int[] arr, int target): Uses == to compare primitive int values directly, since primitives can be compared with equality operators.
• search(String[] arr, String target): Uses .equals() instead of == to compare String content rather than object references.
• return i / return -1: Returns the matching index immediately, or -1 once the loop completes without a match.
• Alternative: You could use Arrays.asList(arr).indexOf(target) for the String version to leverage a built-in list search, though it doesn't work directly for primitive int[] arrays.

public class Main {
    public static int absoluteValue(int value) {
        return value < 0 ? -value : value;
    }

    public static double absoluteValue(double value) {
        return value < 0 ? -value : value;
    }

    public static long absoluteValue(long value) {
        return value < 0 ? -value : value;
    }

    public static void main(String[] args) {
        System.out.println("absoluteValue(-5) = " + absoluteValue(-5));
        System.out.println("absoluteValue(-3.14) = " + absoluteValue(-3.14));
        System.out.println("absoluteValue(-100000000000) = " + absoluteValue(-100000000000L));
    }
}Code language: Java (java)

Explanation:

• value < 0 ? -value : value: Uses a ternary expression to negate the value only if it's negative, returning it unchanged otherwise.
• Separate int, double, and long overloads: Ensures each numeric type is handled with its own precision and range, without relying on implicit widening or narrowing conversions.
• Method resolution: Java automatically picks the overload matching the argument's exact type, or the closest compatible type if no exact match exists.
• Alternative: You could write a single method using double for all inputs, but that would lose precision for large long values and force unnecessary type conversions.

public class Main {
    public static int sumAll(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println("Sum = " + sumAll(1, 2, 3, 4, 5));
    }
}Code language: Java (java)

Explanation:

• int... numbers: Declares a varargs parameter, letting the caller pass any number of int arguments, which Java packages into an array.
• for (int num : numbers): Iterates over the array just like any other array, since varargs behave as arrays inside the method body.
• total += num: Accumulates the sum across all provided arguments.
• Alternative: You could use Arrays.stream(numbers).sum() for a more concise one-liner, though the loop makes the accumulation logic explicit.

public class Main {
    public static String joinStrings(String separator, String... words) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < words.length; i++) {
            result.append(words[i]);
            if (i != words.length - 1) {
                result.append(separator);
            }
        }
        return result.toString();
    }

    public static void main(String[] args) {
        System.out.println("Result = " + joinStrings("-", "Java", "is", "fun"));
    }
}Code language: Java (java)

Explanation:

• String separator, String... words: Places the required separator argument before the varargs parameter, which Java requires since varargs must be the last parameter.
• if (i != words.length - 1): Avoids appending a trailing separator after the final word.
• result.toString(): Converts the accumulated StringBuilder content into the final joined string.
• Alternative: You could use String.join(separator, words) directly, since it accepts a varargs array too, but writing it manually shows how the built-in method works internally.

public class Main {
    public static int findMin(int first, int... rest) {
        int min = first;
        for (int num : rest) {
            if (num < min) {
                min = num;
            }
        }
        return min;
    }

    public static void main(String[] args) {
        System.out.println("Minimum = " + findMin(8, 3, 12, 5, 1));
    }
}Code language: Java (java)

Explanation:

• int first, int... rest: Splits the arguments into one required value and any number of additional values, guaranteeing at least one argument overall.
• int min = first: Initializes the running minimum using the guaranteed first argument, avoiding the need to check for an empty array.
• num < min: Updates the minimum whenever a smaller value is encountered while scanning the remaining arguments.
• Alternative: You could accept a plain int... values array without a required first parameter, but then you would need extra logic to handle the case of zero arguments.

public class Main {
    public static double calculateAverage(double... values) {
        if (values.length == 0) {
            return 0.0;
        }

        double total = 0.0;
        for (double value : values) {
            total += value;
        }

        return total / values.length;
    }

    public static void main(String[] args) {
        System.out.println("Average = " + calculateAverage(4.0, 8.0, 15.0, 16.0));
    }
}Code language: Java (java)

Explanation:

• values.length == 0: Guards against dividing by zero when no arguments are passed, returning 0.0 as a safe default.
• for (double value : values): Iterates over the varargs array to accumulate the total sum of all provided values.
• total / values.length: Divides the sum by the count of values to compute the average.
• Alternative: You could use Arrays.stream(values).average().orElse(0.0), which handles the empty case built in, though the manual loop is clearer for beginners.

public class Main {
    public static void logItems(String storeName, String... items) {
        System.out.println("=== " + storeName + " ===");
        for (int i = 0; i < items.length; i++) {
            System.out.println((i + 1) + ". " + items[i]);
        }
    }

    public static void main(String[] args) {
        logItems("Java Mart", "Bread", "Milk", "Eggs");
    }
}Code language: Java (java)

Explanation:

• String storeName, String... items: Requires a store name while allowing any number of item names to follow.
• "=== " + storeName + " ===": Prints a simple stylized header framing the store name.
• (i + 1) + ". " + items[i]: Numbers each item starting from 1, which reads more naturally than a zero-based index.
• Alternative: You could use a for-each loop with a separate counter variable instead of an index-based loop, though the index-based version is more concise here.

public class Main {
    public static long factorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        System.out.println("Factorial = " + factorial(5));
    }
}Code language: Java (java)

Explanation:

• if (n <= 1): Defines the base case, stopping the recursion once n reaches 0 or 1.
• n * factorial(n - 1): Defines the recursive case, breaking the problem into a smaller version of itself.
• Return type long: Prevents overflow for larger inputs, since factorials grow very quickly.
• Alternative: You could compute the factorial iteratively with a for loop, which avoids the overhead of repeated method calls but doesn't demonstrate recursion.

public class Main {
    public static int fibonacci(int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        System.out.println("Fibonacci(7) = " + fibonacci(7));
    }
}Code language: Java (java)

Explanation:

• if (n == 0) / if (n == 1): Defines the two base cases needed to anchor the recursion, since each Fibonacci number depends on the two before it.
• fibonacci(n - 1) + fibonacci(n - 2): Defines the recursive case, combining the two preceding Fibonacci numbers.
• Call tree: Each call to fibonacci(n) spawns two more calls, so the number of calls grows exponentially with n.
• Alternative: You could use memoization with a Map<Integer, Integer> to cache previously computed values, dramatically reducing redundant calculations for larger inputs.

public class Main {
    public static int sumDigits(int n) {
        if (n == 0) {
            return 0;
        }
        return (n % 10) + sumDigits(n / 10);
    }

    public static void main(String[] args) {
        System.out.println("Sum of Digits = " + sumDigits(1234));
    }
}Code language: Java (java)

Explanation:

• if (n == 0): Defines the base case, stopping the recursion once all digits have been processed.
• n % 10: Extracts the last digit of the current number using the modulus operator.
• n / 10: Removes the last digit using integer division, preparing the smaller sub-problem for the next recursive call.
• Alternative: You could convert the number to a string and iterate over its characters, but the arithmetic approach avoids unnecessary type conversion.

public class Main {
    public static int power(int base, int exponent) {
        if (exponent == 0) {
            return 1;
        }
        return base * power(base, exponent - 1);
    }

    public static void main(String[] args) {
        System.out.println("Result = " + power(2, 10));
    }
}Code language: Java (java)

Explanation:

• if (exponent == 0): Defines the base case, since any number raised to the power of 0 is 1.
• base * power(base, exponent - 1): Defines the recursive case, multiplying the base by the result of a smaller power calculation.
• exponent - 1: Reduces the exponent with each call, guaranteeing the recursion eventually reaches the base case.
• Alternative: You could use a divide-and-conquer approach that halves the exponent each call (exponentiation by squaring), which runs in logarithmic time instead of linear time.

public class Main {
    public static int sumArray(int[] arr, int index) {
        if (index == arr.length) {
            return 0;
        }
        return arr[index] + sumArray(arr, index + 1);
    }

    public static void main(String[] args) {
        System.out.println("Sum = " + sumArray(new int[]{4, 8, 15, 16, 23, 42}, 0));
    }
}Code language: Java (java)

Explanation:

• if (index == arr.length): Defines the base case, stopping the recursion once every element has been processed.
• arr[index] + sumArray(arr, index + 1): Defines the recursive case, adding the current element to the sum of the remaining elements.
• index + 1: Advances the index with each call, ensuring the recursion progresses toward the base case.
• Alternative: You could sum the array from the end backward instead of the front, though starting at the beginning reads more naturally.

public class Main {
    public static void modifyValues(int primitive, int[] reference) {
        primitive = 999;
        reference[0] = 99;
    }

    public static void main(String[] args) {
        int number = 10;
        int[] arr = {1, 2, 3};
        System.out.println("Before: number = " + number + ", arr[0] = " + arr[0]);
        modifyValues(number, arr);
        System.out.println("After: number = " + number + ", arr[0] = " + arr[0]);
    }
}Code language: Java (java)

Explanation:

• primitive = 999: Only reassigns the local copy of the primitive inside the method; the original variable in main is untouched, since primitives are passed by value.
• reference[0] = 99: Modifies the array object itself, which both the caller and the method refer to through their own copies of the same reference.
• Pass-by-value for references: Java always passes a copy of the reference variable, but that copy still points to the same object in memory, so mutations through it are visible outside the method.
• Key takeaway: Reassigning a reference parameter to a brand new array, like reference = new int[]{...}, would not affect the caller's array, but mutating the existing array's contents does.

class Hero {
    private String name;
    private int health;
    private String weapon;

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

    public Hero setHealth(int health) {
        this.health = health;
        return this;
    }

    public Hero setWeapon(String weapon) {
        this.weapon = weapon;
        return this;
    }

    @Override
    public String toString() {
        return "Hero{name='" + name + "', health=" + health + ", weapon='" + weapon + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        Hero player = new Hero().setName("Arthur").setHealth(100);
        System.out.println(player);
    }
}Code language: Java (java)

Explanation:

• return this: Returns a reference to the current object at the end of each setter, which is what enables chaining.
• new Hero().setName("Arthur").setHealth(100): Each method call in the chain operates on and returns the same Hero instance, so the configuration accumulates across the chain.
• Unset weapon field: Remains null since setWeapon() was never called in this example, which the toString() output reflects.
• Alternative: You could use a separate Builder class instead of chaining setters directly on Hero, which better separates construction logic from the object itself for more complex classes.

public class Main {
    public static void processUsername(String username) {
        if (isValid(username)) {
            System.out.println(username + " is a valid username.");
        } else {
            System.out.println(username + " is not a valid username.");
        }
    }

    private static boolean isValid(String user) {
        return user.matches("[a-zA-Z0-9_]+");
    }

    public static void main(String[] args) {
        processUsername("valid_user1");
        processUsername("in valid!");
    }
}Code language: Java (java)

Explanation:

• private boolean isValid(String user): Restricts this helper method to internal use within the class, hiding the validation details from external callers.
• user.matches("[a-zA-Z0-9_]+"): Checks that the entire username consists only of letters, digits, and underscores using a regular expression.
• if (isValid(username)): The public method delegates the validation decision to the helper, keeping its own logic focused on choosing which message to print.
• Alternative: You could inline the regex check directly inside processUsername(), but extracting it into a private helper keeps the public method more readable and the validation logic reusable.

import java.util.Arrays;

public class Main {
    public static void doubleElements(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * 2;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4};
        System.out.println("Before: " + Arrays.toString(nums));
        doubleElements(nums);
        System.out.println("After: " + Arrays.toString(nums));
    }
}Code language: Java (java)

Explanation:

• nums[i] = nums[i] * 2: Overwrites each element with double its original value, modifying the array's contents directly.
• Return type void: The method doesn't need to return anything, since the changes are made directly to the array object the caller already holds a reference to.
• Arrays.toString(nums): Provides a readable string representation of the array's contents for printing.
• Alternative: You could return a brand new array with doubled values instead of modifying in place, which avoids side effects but requires the caller to reassign the result.

import java.util.function.BiFunction;

public class Main {
    public static int operate(int a, int b, BiFunction<Integer, Integer, Integer> operation) {
        return operation.apply(a, b);
    }

    public static void main(String[] args) {
        System.out.println("Addition = " + operate(5, 3, (x, y) -> x + y));
        System.out.println("Subtraction = " + operate(5, 3, (x, y) -> x - y));
        System.out.println("Multiplication = " + operate(5, 3, (x, y) -> x * y));
    }
}Code language: Java (java)

Explanation:

• BiFunction<Integer, Integer, Integer> operation: Represents a function that takes two Integer inputs and produces an Integer result, allowing behavior to be passed as an argument.
• operation.apply(a, b): Executes whichever operation was supplied at the call site, without the method itself knowing the specific logic in advance.
• (x, y) -> x + y: A lambda expression that implements the BiFunction interface inline, defining addition without a separate named method.
• Alternative: You could define named methods for each operation and pass method references, like Integer::sum, instead of writing lambda expressions directly.