Introduction

Finding the second highest value in a Java array sounds simple until you define the edge cases. The real question is whether you want the second element after sorting or the second distinct value. Most production code and interview problems mean the second distinct value, so the implementation should say that clearly.

Define the Contract First

Before writing code, decide how duplicates behave. For the array [9, 9, 7], one interpretation returns 9 because it is the second element in descending order. The more common interpretation returns 7 because it is the second distinct highest value.

Once that rule is fixed, the code becomes straightforward. The examples below implement the second distinct highest value and throw an exception when no such value exists.

Single-Pass Solution

The most efficient general approach is one scan with two trackers. One variable stores the current highest value, and the other stores the current second distinct highest value.

1public class SecondHighestFinder {
2    public static int secondDistinctHighest(int[] values) {
3        if (values == null || values.length < 2) {
4            throw new IllegalArgumentException("Need at least two values");
5        }
6
7        Integer highest = null;
8        Integer secondHighest = null;
9
10        for (int value : values) {
11            if (highest == null || value > highest) {
12                if (highest == null || value != highest) {
13                    secondHighest = highest;
14                }
15                highest = value;
16            } else if (value != highest
17                    && (secondHighest == null || value > secondHighest)) {
18                secondHighest = value;
19            }
20        }
21
22        if (secondHighest == null) {
23            throw new IllegalArgumentException("No second distinct value");
24        }
25
26        return secondHighest;
27    }
28
29    public static void main(String[] args) {
30        int[] numbers = {7, 2, 9, 4, 9, 5};
31        System.out.println(secondDistinctHighest(numbers));
32    }
33}

This runs in O(n) time and uses O(1) extra space. That is better than sorting when you only need one answer.

Why This Loop Works

The loop keeps two facts true while it scans:

• 'highest is the largest value seen so far.'
• 'secondHighest is the largest value seen so far that is still smaller than highest.'

When a new maximum appears, the old maximum becomes the new candidate for second place. When a value is not the maximum but is still larger than the current second place, it replaces secondHighest.

Using Integer instead of primitive int avoids sentinel values such as Integer.MIN_VALUE, which can break the logic if that value appears in the input.

Sorting Approach

Sorting is often easier to explain, though it is less efficient. It is acceptable when the array is already being copied or sorted for another reason.

1import java.util.Arrays;
2
3public class SecondHighestSorted {
4    public static int secondDistinctHighest(int[] values) {
5        if (values == null || values.length < 2) {
6            throw new IllegalArgumentException("Need at least two values");
7        }
8
9        int[] copy = Arrays.copyOf(values, values.length);
10        Arrays.sort(copy);
11
12        int highest = copy[copy.length - 1];
13        for (int i = copy.length - 2; i >= 0; i--) {
14            if (copy[i] != highest) {
15                return copy[i];
16            }
17        }
18
19        throw new IllegalArgumentException("No second distinct value");
20    }
21}

This version is easy to read, but it costs O(n log n) time and usually creates a copy so the original array is not mutated.

Testing the Edge Cases

The happy path is not the hard part. The hard part is arrays that make hidden assumptions fail.

1public class SecondHighestTest {
2    public static void main(String[] args) {
3        System.out.println(SecondHighestFinder.secondDistinctHighest(new int[]{5, 1, 3, 4}));
4        System.out.println(SecondHighestFinder.secondDistinctHighest(new int[]{9, 9, 7, 3}));
5        System.out.println(SecondHighestFinder.secondDistinctHighest(new int[]{-5, -1, -3}));
6    }
7}

Useful test cases include duplicate maximum values, all-identical arrays, negative numbers, very short arrays, and input containing Integer.MIN_VALUE.

When a Stream Is Acceptable

Java streams can express the idea compactly, but they are not usually the clearest or most efficient choice for this specific task. They add boxing, sorting, and intermediate operations for something a plain loop handles directly. If the team prefers streams for consistency, they are still valid, but the one-pass loop is usually the better default.

Common Pitfalls

• Failing to define whether duplicates count toward the second highest result.
• Returning the maximum value again when the requirement was "second distinct highest."
• Using sentinel numeric values and breaking on extreme integer inputs.
• Sorting the array in place when callers expected the original order to remain unchanged.
• Forgetting to handle arrays where all elements are identical.

Summary

• Decide first whether the requirement is second element after sorting or second distinct highest.
• A one-pass scan is the best general solution for the distinct case.
• Sorting works, but it is slower and may mutate input unless you copy the array.
• Edge cases matter more than the basic loop.
• Use clear exceptions when no second distinct value exists.