How do I simplify/combine these two methods for finding the smallest and largest int in an array?

Question

I've written two methods to find the smallest and largest int in an array, but they're nearly identical, so I feel like there should be some way to simplify this, perhaps as one method?

private int findMin(){
    int min = arr[0];
    for(int num : arr){
        if(num<min) {
            min = num;
        }
    }
    return min;
}

private int findMax(){
    int max = arr[0];
    for(int num : arr){
        if(num>max){
            max = num;
        }
    }
    return max;
}

I'm not sure how to approach this sort of issue, so I'd love to see your responses!

While this question on how to pass arithmetic operators to a method and this question on how to get both min and max value of Java 8 stream answer the literal programming problem, my question is on a more fundamental level about to how to approach the problem of methods doing similar things, and ways to compare arrays in general. The answers to this post have been significantly more helpful to me than the answers to those questions.

Answer 1

You can implement just one, say findMax, and pass it a Comparator that indicates how comparisons should be done:

private int findMax(Comparator<Integer> comparator) {
    int max = arr[0];
    for (int num : arr) {
        if (comparator.compare(num, max) > 0) {
            max = num;
        }
    }
    return max;
}

Pass Comparator.naturalOrder() for the natural ordering of integers, so you get the maximum.

Pass Comparator.reverseOrder() for the reverse ordering, so you get the minimum.

Answer 2

Your methods are already available in IntStream that also deals with empty arrays (indeterminate extremes).

private OptionalInt findMin() {
    return IntStream.of(arr).min();
}

private OptionalInt findMax() {
    return IntStream.of(arr).max();
}

And like your choice of throwing exceptions:

private int findMin() {
    return IntStream.of(arr).min().get();
}

private int findMax() {
    return IntStream.of(arr).max().get();
}

Or as method reference:

Function<IntStream, OptionalInt> extreme = IntStream::max;

Also consider the parallel feature:

IntStream.of(arr).parallel().min();

---

@Yay295 reminded us of IntSummaryStatistics:

IntSummaryStatistics stats = new IntSummaryStatistics();
IntStream.of(arr).stream()
    .forEach(stats); // stats is an int consumer too.

or when doing more

IntSummaryStatistics stats = IntStream.of(arr)
    .collect(Collectors.summarizingInt(IntSummaryStatistics::new,
                    IntSummaryStatistics::accept, 
                    IntSummaryStatistics::combine);

and then several numbers can be asked:

int min = stats.getMin();
int max = stats.getMax();
int avg = stats.getAverage();
int sum = stats.getSum();

---

Feedback of @draspa44

You can end any IntStream, LongStream or DoubleStream simply with .summaryStatistics(). I think this is easier to read than mutating stats or using accept and combine

IntSummaryStatistics stats = IntStream.of(arr)
    .summaryStatistics();

Answer 3

I would not recommend combine two responsibilities into one method

Instead, I would make two methods (max and min) that share same lines of code through a third method.

public int min(int[] array){
    return most(array, (a, b) -> a < b)
}

public int max(int[] array){
    return most(array, (a, b) -> a > b)
}

private int most(int[] array, Fuction2 compare){
    int most = array[0];
    for (int num : array) {
        if (compare(num, most)) {
            most = num;
        }
    }
    return most;
}

This way you can easily change logic for one method, without changing another Also, it is easier to use and more readable, than using one method with parameter like "max=true"

Answer 4

If the number of int's is big and you most of the time need both min and max values, it probably makes sense to go through the list only once and evaluate both min and max at the same time.

Then there is just the question how to communicate two numbers when a function can only have one return value. So we create a special result class for this.

class MinMaxResult {
    public int min = 0;
    public int max = 0;
}

MinMaxResult findMinMax() {
    MinMaxResult result = new MinMaxResult();
    result.min = arr[0];
    result.max = arr[0];

    for (int num: arr) {
        if (num < result.min) {
            result.min = num;
        } else if (num > result.max) {
            result.max = num;
        }
    }

    return result;
}

Answer 5

You can also call the class methods Math.min and Math.max as follows and return the results in a record. Records are immutable classes and were introduced in Java 14.

record MinMax(int min, int max) {
};

public static void main(String[] args) {
  

    int[] v = { 1, 1, 20, 3, 3, 10 };

    MinMax result = findMinMax(v);
    System.out.println(result);
    // or
    System.out.println(result.min + ", "+ result.max);
}

prints

MinMax[min=1, max=20]
1, 20

Just iterate over the array and apply the methods to each value and the current value of min or max.

public static MinMax findMinMax(int[] values) {
    int max = values[0];
    int min = max;
    for (int i = 1; i < values.length; i++) {
        max = Math.max(max, values[i]);
        min = Math.min(min, values[i]);
    }
    return new MinMax(min, max);
}

Answer 6

Since there is really only one difference, you can pass a boolean to determine which value (min or max) you want. Something like this:

private int findExtreme(boolean findMin) {
    int solution = arr[0];
        for(int num : arr){
            if (findMin){
                if(num<min){
                    solution = num;
                }
            } else {
                if(num>max){
                    solution = num;
                }
            }
        }
    return solution;
}

Answer 7

You can pass in a boolean that is true to find the minimum or false to find the maximum. The trick is to compare the result of (num < best), which is either true or false, to the boolean argument.

• If isMinimum is true then when (num < best) is true we have a new minimum.
• If isMinimum is false then when (num < best) is false we have a new maximum (or a tie for maximum).

private int findExtreme(bool isMinimum) {
    int best = arr[0];
    for (int num: arr) {
        if ((num < best) == isMinimum) {
            best = num;
        }
    }
    return best;
}

Even better would be to use an enum. Boolean arguments can be hard to decipher just seeing a bare true or false in a function call. That would look like:

public enum Extreme {
    MINIMUM,
    MAXIMUM
}

private int find(Extreme extreme) {
    int best = arr[0];
    for (int num: arr) {
        if ((num < best) == (extreme == Extreme.MINIMUM)) {
            best = num;
        }
    }
    return best;
}