Greatest Of Three Numbers In Java Program

Finding the greatest among three numbers is a common programming task that helps beginners understand conditional logic. It involves comparing values to determine which one holds the maximum.

In this article, you will learn how to determine the greatest of three numbers in Java using various conditional constructs and built-in methods.

Problem Statement

The challenge is to identify the largest value when given three distinct or non-distinct numerical inputs. This seemingly simple problem forms the basis for more complex decision-making processes in software applications, such as ranking, sorting, or selecting optimal parameters. For example, comparing product prices to find the lowest, or student scores to determine the highest.

Example

Consider three numbers: 25, 78, and 43. The program should identify 78 as the greatest among these three.

Background & Knowledge Prerequisites

To understand the solutions presented, readers should have a basic understanding of:

• Java Variables: Declaring and assigning values to integer variables.
• Input/Output: Reading input from the console using Scanner and printing output.
• Conditional Statements: if, else if, and else constructs.
• Logical Operators: && (AND) for combining conditions.
• Ternary Operator: A shorthand for simple if-else statements.
• Math Class: Basic usage of methods like Math.max().

Use Cases or Case Studies

Determining the greatest of three numbers is a fundamental operation with several practical applications:

• Ranking System: In a small competition with three participants, finding the highest score to declare a winner.
• Resource Allocation: Identifying the busiest server among three to redirect traffic, or the machine with the most available memory.
• Financial Analysis: Comparing the returns of three different investment options over a period to choose the best performer.
• Sensor Data Processing: In an IoT setup, reading temperatures from three different sensors and identifying the highest reading to detect a potential hotspot.
• Game Development: Comparing player scores or resource counts to determine who has the lead in a three-player scenario.

Solution Approaches

Here are several methods to find the greatest of three numbers in Java, ranging from basic conditional statements to more advanced built-in functions.

Approach 1: Using if-else if-else statements

This is the most straightforward and intuitive method, suitable for beginners. It involves a series of comparisons to check which number is the largest.

Summary: This approach uses a sequence of if-else if-else blocks to compare the three numbers and determine the greatest based on direct comparisons.

// Greatest of Three Numbers using if-else if-else
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object to read input from the console
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt the user to enter three numbers
        System.out.print("Enter the first number: ");
        int num1 = scanner.nextInt();

        System.out.print("Enter the second number: ");
        int num2 = scanner.nextInt();

        System.out.print("Enter the third number: ");
        int num3 = scanner.nextInt();

        // Step 3: Use if-else if-else to find the greatest number
        int greatest;
        if (num1 >= num2 && num1 >= num3) {
            greatest = num1;
        } else if (num2 >= num1 && num2 >= num3) {
            greatest = num2;
        } else {
            greatest = num3;
        }

        // Step 4: Print the greatest number
        System.out.println("The greatest number is: " + greatest);

        // Step 5: Close the scanner to prevent resource leaks
        scanner.close();
    }
}

Run

Sample Output:

Enter the first number: 25
Enter the second number: 78
Enter the third number: 43
The greatest number is: 78

Stepwise Explanation:

1. Input: The program first initializes a Scanner to accept three integer inputs from the user (num1, num2, num3).
2. First Condition: It checks if num1 is greater than or equal to both num2 AND num3. If true, num1 is the greatest.
3. Second Condition: If the first condition is false, it proceeds to check if num2 is greater than or equal to both num1 AND num3. If true, num2 is the greatest.
4. Else Block: If neither of the above conditions is met, it means num3 must be the greatest (as it's not smaller than both others), and greatest is set to num3.
5. Output: Finally, the determined greatest number is printed to the console.

Approach 2: Using Nested if-else statements

This approach uses if statements nested within other if statements, providing a slightly different logical flow.

Summary: This method uses nested if-else blocks to compare numbers sequentially. An outer if determines the greater of the first two, and an inner if compares that result with the third number.

// Greatest of Three Numbers using Nested if-else
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object and read three numbers
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the first number: ");
        int num1 = scanner.nextInt();

        System.out.print("Enter the second number: ");
        int num2 = scanner.nextInt();

        System.out.print("Enter the third number: ");
        int num3 = scanner.nextInt();

        // Step 2: Use nested if-else to find the greatest number
        int greatest;
        if (num1 >= num2) {
            if (num1 >= num3) {
                greatest = num1; // num1 is greatest
            } else {
                greatest = num3; // num3 is greatest (num1 was > num2, but num3 > num1)
            }
        } else { // num2 > num1
            if (num2 >= num3) {
                greatest = num2; // num2 is greatest
            } else {
                greatest = num3; // num3 is greatest (num2 was > num1, but num3 > num2)
            }
        }

        // Step 3: Print the greatest number
        System.out.println("The greatest number is: " + greatest);

        // Step 4: Close the scanner
        scanner.close();
    }
}

Run

Sample Output:

Enter the first number: 25
Enter the second number: 78
Enter the third number: 43
The greatest number is: 78

Stepwise Explanation:

1. Input: Similar to the previous approach, the program takes three integer inputs.
2. Outer Comparison: It first compares num1 and num2.

• If num1 is greater than or equal to num2, then num1 is potentially the greatest.
• If num1 is less than num2, then num2 is potentially the greatest.

1. Inner Comparison:

• If num1 >= num2, then num1 is compared with num3. The larger of these two is the greatest.
• If num2 > num1, then num2 is compared with num3. The larger of these two is the greatest.

1. Output: The final greatest number is printed.

Approach 3: Using the Ternary Operator

The ternary operator (? :) offers a concise way to write simple if-else conditions.

Summary: This approach uses the ternary operator, which evaluates a condition and returns one of two expressions based on the condition's truthiness. It can be chained for multiple comparisons.

// Greatest of Three Numbers using Ternary Operator
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object and read three numbers
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the first number: ");
        int num1 = scanner.nextInt();

        System.out.print("Enter the second number: ");
        int num2 = scanner.nextInt();

        System.out.print("Enter the third number: ");
        int num3 = scanner.nextInt();

        // Step 2: Use nested ternary operators to find the greatest number
        int greatest = (num1 >= num2) ? ((num1 >= num3) ? num1 : num3) : ((num2 >= num3) ? num2 : num3);

        // Step 3: Print the greatest number
        System.out.println("The greatest number is: " + greatest);

        // Step 4: Close the scanner
        scanner.close();
    }
}

Run

Sample Output:

Enter the first number: 25
Enter the second number: 78
Enter the third number: 43
The greatest number is: 78

Stepwise Explanation:

1. Input: The program takes three integer inputs.
2. Outer Ternary: (num1 >= num2) first compares num1 and num2.

• If num1 >= num2 is true, the expression ((num1 >= num3) ? num1 : num3) is evaluated.
• If num1 >= num2 is false (meaning num2 > num1), the expression ((num2 >= num3) ? num2 : num3) is evaluated.

1. Inner Ternary (if num1 >= num2): (num1 >= num3) ? num1 : num3 compares num1 with num3. The larger of these two becomes the greatest.
2. Inner Ternary (if num2 > num1): (num2 >= num3) ? num2 : num3 compares num2 with num3. The larger of these two becomes the greatest.
3. Output: The result stored in greatest is printed. This method is compact but can be harder to read for complex conditions.

Approach 4: Using Math.max() method

Java's Math class provides a max() method that can find the maximum of two numbers. This can be used repeatedly for three numbers.

Summary: This approach leverages the built-in Math.max() method, which efficiently returns the larger of two given arguments. It can be nested to handle three or more numbers.

// Greatest of Three Numbers using Math.max()
import java.util.Scanner; // Only needed for user input, Math class is built-in

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object and read three numbers
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the first number: ");
        int num1 = scanner.nextInt();

        System.out.print("Enter the second number: ");
        int num2 = scanner.nextInt();

        System.out.print("Enter the third number: ");
        int num3 = scanner.nextInt();

        // Step 2: Use Math.max() to find the greatest number
        // First, find the max of num1 and num2
        int tempMax = Math.max(num1, num2);
        // Then, find the max of tempMax and num3
        int greatest = Math.max(tempMax, num3);

        // Alternatively, in a single line:
        // int greatest = Math.max(num1, Math.max(num2, num3));


        // Step 3: Print the greatest number
        System.out.println("The greatest number is: " + greatest);

        // Step 4: Close the scanner
        scanner.close();
    }
}

Run

Sample Output:

Enter the first number: 25
Enter the second number: 78
Enter the third number: 43
The greatest number is: 78

Stepwise Explanation:

1. Input: The program receives three integer inputs.
2. First Math.max(): Math.max(num1, num2) is called to determine the larger between num1 and num2. The result is stored in tempMax.
3. Second Math.max(): Math.max(tempMax, num3) is then called to compare tempMax (which is the larger of num1 and num2) with num3. The result is the overall greatest number.
4. Output: The greatest number is printed. This approach is highly readable and concise for finding the maximum of a few numbers.

Conclusion

Finding the greatest of three numbers in Java can be achieved through several methods, each with its own advantages. The if-else if-else approach is fundamental and easy to understand for beginners, while nested if-else structures offer an alternative logical flow. The ternary operator provides a more compact syntax for simple comparisons, and the Math.max() method offers the most concise and often most readable solution, especially when dealing with multiple comparisons.

Summary

• Problem: Identify the largest value among three given numbers.
• if-else if-else: Uses sequential conditions to compare numbers, ideal for clarity and beginners.
• Nested if-else: Compares numbers in a hierarchical manner, useful for structured decision-making.
• Ternary Operator: A concise inline solution for simple if-else logic, improving code brevity.
• Math.max() Method: Leverages a built-in Java function for an elegant and readable solution, especially effective for multiple comparisons.
• Readability: For three numbers, Math.max() often provides the most readable code, while if-else if-else is also very clear.