Program To Find Largest And Smallest Element In An Array In Java

Finding the largest and smallest elements within an array is a common programming task. This operation is fundamental for various data analysis and optimization problems, requiring an efficient way to identify the extreme values in a collection of data.

In this article, you will learn how to efficiently find the largest and smallest elements in an array using different approaches in Java.

Problem Statement

Given an array of integers, the goal is to identify and return both the largest and the smallest elements present in that array. This problem is crucial when dealing with datasets where understanding the range of values, outliers, or specific thresholds is important. The challenge lies in performing this operation efficiently, especially for large arrays, to minimize computational resources.

Example

Consider the following integer array: [12, 5, 8, 20, 3, 15]

The expected output would be: Largest element: 20 Smallest element: 3

Background & Knowledge Prerequisites

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

• Java Arrays: How to declare, initialize, and access elements in an array.
• Loops: for loops for iterating over array elements.
• Conditional Statements: if statements for comparing values.
• Basic Data Types: Understanding int and Integer in Java.
• Java Collections (for some approaches): Familiarity with java.util.Arrays class methods.

No specific setup is required beyond a standard Java Development Kit (JDK) installation to compile and run the programs.

Use Cases or Case Studies

Identifying the largest and smallest elements in an array has numerous practical applications across various domains:

• Data Analysis: Finding the minimum and maximum temperatures recorded in a day, highest and lowest scores in a test, or extreme stock prices.
• Image Processing: Determining the brightest and darkest pixels in an image for contrast adjustments.
• Game Development: Identifying the highest or lowest score achieved by players, or the minimum/maximum health points of characters.
• Financial Modeling: Calculating the range of values for a particular financial instrument over a period to assess volatility.
• Sensor Data Monitoring: Detecting abnormal readings (outliers) by comparing current sensor values to historical minimums and maximums.

Solution Approaches

Here are three common approaches to find the largest and smallest elements in a Java array.

Approach 1: Iteration (Looping Through the Array)

This approach involves iterating through the array once, comparing each element with the currently tracked largest and smallest values.

• Summary: Initialize max with the smallest possible integer value and min with the largest possible integer value. Then, traverse the array, updating max and min whenever a larger or smaller element is encountered.

// FindLargestAndSmallestUsingIteration
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        int[] numbers = {12, 5, 8, 20, 3, 15}; // Example array

        // Step 1: Initialize max and min with extreme values
        // Integer.MIN_VALUE and Integer.MAX_VALUE are used
        // to ensure any array element will be correctly identified
        // as either larger than current max or smaller than current min.
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        // Step 2: Iterate through the array
        for (int i = 0; i < numbers.length; i++) {
            // Step 3: Compare current element with max
            if (numbers[i] > max) {
                max = numbers[i]; // Update max if current element is larger
            }

            // Step 4: Compare current element with min
            if (numbers[i] < min) {
                min = numbers[i]; // Update min if current element is smaller
            }
        }

        // Step 5: Print the results
        System.out.println("Array elements: " + java.util.Arrays.toString(numbers));
        System.out.println("Largest element: " + max);
        System.out.println("Smallest element: " + min);
    }
}

Run

Sample Output:

Array elements: [12, 5, 8, 20, 3, 15]
Largest element: 20
Smallest element: 3

Stepwise Explanation:

1. An integer array numbers is defined.
2. Two variables, max and min, are initialized. max is set to Integer.MIN_VALUE (the smallest possible int value) and min is set to Integer.MAX_VALUE (the largest possible int value). This ensures that the first element of the array will correctly become both the initial max and min.
3. A for loop iterates through each element of the array from the first to the last.
4. Inside the loop, for each element numbers[i]:

• It is compared with the current max. If numbers[i] is greater than max, max is updated to numbers[i].
• It is compared with the current min. If numbers[i] is less than min, min is updated to numbers[i].

1. After the loop finishes, max will hold the largest element and min will hold the smallest element found in the array.
2. The results are then printed to the console.

Approach 2: Sorting the Array

Sorting the array is another straightforward way to find the extreme elements. Once sorted, the smallest element will be at the beginning and the largest at the end.

• Summary: Sort the array in ascending order using Arrays.sort(). The smallest element will be at index 0 and the largest at the last index.

// FindLargestAndSmallestUsingSorting
import java.util.Arrays; // Required for Arrays.sort()
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        int[] numbers = {12, 5, 8, 20, 3, 15}; // Example array

        // Step 1: Print the original array
        System.out.println("Original array elements: " + Arrays.toString(numbers));

        // Step 2: Sort the array in ascending order
        Arrays.sort(numbers);

        // Step 3: The smallest element is at index 0
        int min = numbers[0];

        // Step 4: The largest element is at the last index
        int max = numbers[numbers.length - 1];

        // Step 5: Print the results
        System.out.println("Sorted array elements: " + Arrays.toString(numbers));
        System.out.println("Largest element: " + max);
        System.out.println("Smallest element: " + min);
    }
}

Run

Sample Output:

Original array elements: [12, 5, 8, 20, 3, 15]
Sorted array elements: [3, 5, 8, 12, 15, 20]
Largest element: 20
Smallest element: 3

Stepwise Explanation:

1. An integer array numbers is defined.
2. The Arrays.sort(numbers) method is called to sort the array elements in ascending order. This modifies the array in place.
3. After sorting, the smallest element will always be at the first position (index 0) of the array. This value is assigned to min.
4. The largest element will always be at the last position (numbers.length - 1) of the array. This value is assigned to max.
5. The results are then printed.

Approach 3: Using Java Streams (Modern Java)

Java 8 introduced Streams, providing a more functional and concise way to process collections.

• Summary: Convert the array to an IntStream, then use the min() and max() terminal operations to find the extreme values.

// FindLargestAndSmallestUsingStreams
import java.util.Arrays; // Required for Arrays.stream()
import java.util.OptionalInt; // Required for OptionalInt
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        int[] numbers = {12, 5, 8, 20, 3, 15}; // Example array

        // Step 1: Convert the array to an IntStream
        // IntStream provides methods for processing primitive int values
        OptionalInt minOptional = Arrays.stream(numbers).min();
        OptionalInt maxOptional = Arrays.stream(numbers).max();

        // Step 2: Check if the array is not empty before getting values
        // min() and max() return OptionalInt to handle empty streams gracefully
        if (minOptional.isPresent() && maxOptional.isPresent()) {
            int min = minOptional.getAsInt();
            int max = maxOptional.getAsInt();

            // Step 3: Print the results
            System.out.println("Array elements: " + Arrays.toString(numbers));
            System.out.println("Largest element: " + max);
            System.out.println("Smallest element: " + min);
        } else {
            System.out.println("The array is empty. Cannot find min/max.");
        }
    }
}

Run

Sample Output:

Array elements: [12, 5, 8, 20, 3, 15]
Largest element: 20
Smallest element: 3

Stepwise Explanation:

1. An integer array numbers is defined.
2. Arrays.stream(numbers) converts the int array into an IntStream.
3. The min() method is called on the IntStream to find the smallest element. It returns an OptionalInt because the stream might be empty.
4. Similarly, the max() method is called to find the largest element, also returning an OptionalInt.
5. A check if (minOptional.isPresent() && maxOptional.isPresent()) ensures that the array was not empty before attempting to retrieve the int values using getAsInt().
6. The retrieved min and max values are then printed.

Conclusion

Finding the largest and smallest elements in an array is a fundamental task with multiple solutions in Java. The iterative approach offers the most efficient solution in terms of time complexity (O(N)), as it requires only a single pass through the array. Sorting provides a clean solution but has a higher time complexity (O(N log N) for typical sorting algorithms). Java Streams offer a modern, concise, and readable way to achieve the same result, often with performance comparable to iteration for this specific task, though they introduce some overhead due to stream creation.

Summary

• Problem: Identify the highest and lowest values in an integer array.
• Iterative Approach:
• Initialize max to Integer.MIN_VALUE and min to Integer.MAX_VALUE.
• Loop once through the array, updating max and min with larger or smaller elements found.
• Pros: Most efficient (O(N) time complexity).
• Cons: More verbose than other methods.
• Sorting Approach:
• Sort the array using Arrays.sort().
• The smallest element is at index 0, the largest at array.length - 1.
• Pros: Simple to implement using built-in methods.
• Cons: Higher time complexity (O(N log N)) due to sorting.
• Java Streams Approach:
• Convert array to IntStream using Arrays.stream().
• Use min() and max() terminal operations, handling OptionalInt results.
• Pros: Concise, readable, functional style.
• Cons: Can have slight overhead compared to direct iteration; returns OptionalInt which needs to be handled.
• Best Practice: For performance-critical applications, the iterative approach is generally preferred. For readability and functional programming style, especially in modern Java, Streams are an excellent choice.