Java Program to Find Largest Element in an Array

Try it on GfG Practice

Finding the largest element in an array is a common programming task. There are multiple approaches to solve it. In this article, we will explore four practical approaches one by one to solve this in Java.

Example Input/Output:

Input: arr = { 1, 2, 3, 4, 5}
Output: 5

Input: arr = { 10, 3, 5, 7, 2, 12}
Output: 12

Input: arr = { 12 }
Output: 12

Approaches to Find the Largest Element in an Array

Below are the 4 main approaches:

1. Iterative Approach
2. Java 8 Stream
3. Sorting
4. Using Collections.max()

1. Iterative Approach

The most common method to find and print the largest element of a Java array is to iterate over each element of the array and compare each element with the largest value.

Algorithm:

• We assume that the first element is the largest and initialize the first element as the largest number ( max = arr[0]).
• Then, we traverse through each element of the array and compare it with each element of the array one by one.
• If the current element is greater than the maximum, then we update the maximum ( max = arr[I]).
• When the loop is finished. We get the largest element and print it.

Example:

// Java Program to find the largest element in 
// array using iterative approach
class Geeks 
{
    // Array declared
    static int arr[] = {20, 10, 20, 4, 100}; 
    
    // Method to find maximum in arr[] 
    static int largest() 
    {       
        // Initialize maximum element 
        int max = arr[0]; 
        
      	// Traversing and comparing max element
        for (int i = 1; i < arr.length; i++)
        
         // If current element is greater than max
            if (arr[i] > max) 
            
                // Then update max element
                max = arr[i]; 
        
        return max; 
    } 
    
    public static void main(String[] args) 
    {    
      
        System.out.println(largest()); 
    } 
} 

100

Explanation: In the above example, we traverse through each element of the array and check if the current element is greater than the max element so we update the max element and after reaching the end of the array we get the maximum array present in the array.

Complexity Analysis:

• Time Complexity: O(N)
• Space Complexity: O(1)

2. Using Java 8 Stream (Used for Java 8+)

Best used for concise and parallelizable with other operations with the Time complexity of O(N).

Example:

// Java Program to Find the Largest
// Element in Array using Java Stream
import java.util.Arrays; 

public class Geeks
{
    public static void main(String[] args)
    {
        int arr[] = {20, 10, 20, 4, 100}; 
        
        // Java Stream and max to find the 
      	// max element in array
        int max = Arrays.stream(arr).max().getAsInt(); 
      
        System.out.println(max); 
    } 

} 

100

Complexity Analysis:

• Time Complexity: O(N)
• Space Complexity: O(1)

3. Sorting the Array (Used when Sorting is essential)

We can sort the array to get the largest element from the array. After sorting we can directly extract the last element as the largest element (Ascending order). We can use a predefined sort method defined in the util class.

Example:

// Java Program to find the largest element
// in the array using sort function
import java.io.*;
import java.util.*;

class Geeks
{
    public static void main(String[] args)
    {
      	// Array created      
        int arr[] = {20, 10, 20, 4, 100};
          
        // Sorting function using sort function
        Arrays.sort(arr);
      
        System.out.println(arr[arr.length - 1]);
    }
}

100

Complexity Analysis:

• Time Complexity: O(N log(N) )
• Space Complexity: O(1)

Note: Instead of the Arrays.sort() method we can also use the user-defined sorting method.

3. Using Collections.max() (Used with ArrayList)

The max() method of java.util.Collections class is used to return the maximum element of the given collection, according to the natural ordering of its elements.

Example:

// Java Program to find the maximum element
// in an Array using Collections.max() method
import java.util.*;

public class Geeks
{
    public static void main(String[] args)
    {      
        // Declaring array
        int arr[] = {20, 10, 20, 4, 100};

        // Creating new list
        List<Integer> list = new ArrayList<>();
      
        // Adding elements in list
        for (int i = 0; i < arr.length; i++) 
            list.add(arr[i]);

        // Using the method to find the
        // maximum element
        System.out.println(Collections.max(list));
    }
}

100

Complexity Analysis:

• Time Complexity: O(N)
• Space Complexity: O(N)

Approaches Comparision

GeeksforGeeks

Improve

Article Tags :

• Java
• Java Programs
• Java-Arrays

Practice Tags :

• Java