Java Program to Find Largest Element in an Array
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.
Example 1: Here, we are using the iterative approach or naive approach to find the largest element in an array.
// 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)
{
// Print the largest element
System.out.println(largest());
}
}
Output
100
Explanation: In the above code, 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)
Other Methods to Find the Largest Element in an Array
- Java 8 Stream
- Sorting
- Using Collections.max()
1. 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 2: Using Java Streams to find the maximum element in an array.
// 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();
// Printing the result
System.out.println(max);
}
}
Output
100
Complexity Analysis:
- Time Complexity: O(N)
- Space Complexity: O(1)
2. 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 3: Sorting (Ascending order) the array to get the largest element in the array (last element).
// 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);
// Printing the result
System.out.println(arr[arr.length - 1]);
}
}
Output
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 4: Using the collections to get the largest element in the array.
// 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));
}
}
Output
100
Complexity Analysis:
- Time Complexity: O(N)
- Space Complexity: O(N)
Please refer complete article on Program to find the largest element in an array for more details!
