Java Program to Find the Largest Element in an Array

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Introduction

Finding the largest element in an array is a common programming task. There are several ways to achieve this, each with its own advantages and use cases. In this guide, we'll explore different methods for finding the largest element in an array using Java.

Table of Contents

1. Using a Simple Loop
2. Using Java 8 Streams
3. Using Collections
4. Using Recursion
5. Example Programs with Output

1. Using a Simple Loop

The most straightforward way to find the largest element in an array is to iterate through it using a loop.

Example:

public class LargestElementUsingLoop {
    public static void main(String[] args) {
        int[] array = {10, 20, 5, 25, 15};

        // Find the largest element using a simple loop
        int max = findLargest(array);

        // Print the largest element
        System.out.println("Largest element using loop: " + max);
    }

    public static int findLargest(int[] array) {
        int max = array[0]; // Assume the first element is the largest

        // Iterate through the array
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i]; // Update max if current element is larger
            }
        }
        return max;
    }
}

Output:

Largest element using loop: 25

2. Using Java 8 Streams

Java 8 introduced Streams, which can be used to find the largest element in a more declarative way.

Example:

import java.util.Arrays;

public class LargestElementUsingStreams {
    public static void main(String[] args) {
        int[] array = {10, 20, 5, 25, 15};

        // Find the largest element using streams
        int max = Arrays.stream(array).max().getAsInt();

        // Print the largest element
        System.out.println("Largest element using streams: " + max);
    }
}

Output:

Largest element using streams: 25

3. Using Collections

If you convert the array to a list, you can use the Collections.max() method to find the largest element.

Example:

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

public class LargestElementUsingCollections {
    public static void main(String[] args) {
        Integer[] array = {10, 20, 5, 25, 15};

        // Convert array to list
        List<Integer> list = Arrays.asList(array);

        // Find the largest element using Collections.max()
        int max = Collections.max(list);

        // Print the largest element
        System.out.println("Largest element using Collections: " + max);
    }
}

Output:

Largest element using Collections: 25

4. Using Recursion

A more advanced method involves using recursion to find the largest element in the array.

Example:

public class LargestElementUsingRecursion {
    public static void main(String[] args) {
        int[] array = {10, 20, 5, 25, 15};

        // Find the largest element using recursion
        int max = findLargest(array, array.length);

        // Print the largest element
        System.out.println("Largest element using recursion: " + max);
    }

    public static int findLargest(int[] array, int n) {
        // Base case: if the array has only one element, return it
        if (n == 1) {
            return array[0];
        }

        // Recursive case: find the largest element in the rest of the array
        return Math.max(array[n - 1], findLargest(array, n - 1));
    }
}

Output:

Largest element using recursion: 25

Conclusion

In this guide, we explored different ways to find the largest element in an array using Java. Each method has its own advantages:

• Using a Simple Loop: Straightforward and easy to understand.
• Using Java 8 Streams: Declarative and concise.
• Using Collections: Utilizes built-in utilities for working with collections.
• Using Recursion: Demonstrates a more advanced approach and can be useful for educational purposes.

Understanding these methods will help you choose the best approach based on your specific use case and improve your problem-solving skills in Java.