Java 8: Replace traditional for loop

Question

What's the best & concise way to change the code given below in Java 8:

static int[] breakingRecords(int[] scores) {
    int lowest = 0, highest = 0, countlow = 0, counthigh = 0;
    for (int i = 0; i < scores.length; i++) {
        if (i == 0) {
            lowest = scores[0];
            highest = scores[0];
        } else {
            if (scores[i] < lowest) {
                lowest = scores[i];
                countlow++;
            } else if (scores[i] > highest) {
                highest = scores[i];
                counthigh++;
            }
        }
    }
    int rc[] = {counthigh, countlow};
    return rc;
}

Note: I know that I can use:

IntStream.range(0, 10).forEach(
    i -> {
      if (i == 0) {
            ...
    }

But to do so, I need to declare all the variables as AtomicInteger which makes the code verbose & hard to read.

There must be a better way than using AtomicIntegers. Is there?

Answer 1

Let's be much more simpler. You are getting the maximum and minimum values in a Stream.

IntStream provides method for that :

OptionalInt max()
OptionalInt min()

Here is a quick way of how to use it :

int[] array = {5, 6, 10, 2, 5};

OptionalInt max = Arrays.stream(array).max();
OptionalInt min = Arrays.stream(array).min();

System.out.println("min : " + min.getAsInt());
System.out.println("max : " + max.getAsInt());

Note that you get OptionalInt, so you should check for empty values, but this only occurs if the IntStream itself is empty. So you can check that before you even read the array.

EDIT: this solution was proposed before the question include the return showing that the important part is the countHigh and countLow part.

Answer 2

Assuming that "the best way" actually refers to the most performant way ... you are probably already there (or very close to it)!

You see, using IntStream and lambdas might help with readability, but that will not magically increase performance. To the contrary. These constructs come with a certain amount of overhead!

In other words: if your ultimate goal is to write the code that solves the underlying problem in the most efficient way, then "old school" is (most likely) your best option.

Streams play nicely for readability (when used wisely), and they can help with efficient filtering and such, and of course, when using parallelStream() you might be able to get results quicker (by using more threads). But for straight forward simple computations on some array of ints, none of these advantages apply!

Answer 3

You could achieve that by using a custom comparator, which accepts a predicate when to increment the counter and an access method to be able to get said counter:

public class IncrementingComparator implements Comparator<Integer>{
    private final IntPredicate doIncrement;
    private int count;

    public IncrementingComparator(IntPredicate doIncrement){
        this.doIncrement = doIncrement;
    }

    @Override
    public int compare(Integer o1, Integer o2){
        final int compareResult = o1.compareTo(o2);
        if(doIncrement.test(compareResult)){
            count++;
        }
        return compareResult;
    }

    public int count(){
        return count;
    }
}

You then could create 2 instances of above class:

final IncrementingComparator maxCmp = new IncrementingComparator(i -> i > 0);
final IncrementingComparator minCmp = new IncrementingComparator(i -> i < 0);

Which then can be used inside the min() and max() operations of Stream:

final Optional<Integer> max = Arrays.stream(array)
    .boxed()
    .max(maxCmp);
final Optional<Integer> min = Arrays.stream(array)
    .boxed()
    .min(minCmp);

After the min and max are found, you could then extract the count values from each comparator:

final int maxCount = maxCmp.count();
final int minCount = minCmp.count();

Note: Because the Comparators have an internal state, they can only be used once. (Or one could add a reset() method to set the count variable back to 0.