Java Program to Find the Largest Element in an Array

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

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

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare 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.

Using a Simple Loop
Using Java 8 Streams
Using Collections
Using Recursion
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.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog