Java 8：取代传统的for循环[闭合]

Question

想改进这个问题吗 通过编辑此帖子，更新问题，使其只关注一个问题。

什么是最好的

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;
}

注意：我知道我可以使用：

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

但要做到这一点，我需要将所有变量声明为原子整数，这使得代码冗长

一定有比使用原子整数更好的方法。有？

Answer 1

您可以通过使用自定义比较器来实现这一点，该比较器接受何时递增计数器的谓词和能够获取所述计数器的访问方法：

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;
    }
}

然后可以创建上述类的2个实例：

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

然后可以在流的操作中使用：

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

找到最小值和最大值后，可以从每个比较器中提取计数值：

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

注意：因为比较器有内部状态，所以只能使用一次。（或者可以添加一个重置（）方法将count变量设置回0。

Answer 2

假设“最佳方式”实际上指的是最有效的方式。。。你可能已经在那里（或非常接近它）！

您知道，使用IntStream和lambdas可能有助于提高可读性，但这不会神奇地提高性能。恰恰相反。这些构造会带来一定的开销！

换句话说：如果您的最终目标是编写以最有效的方式解决底层问题的代码，那么“老派”很可能是您的最佳选择。

流的易读性很好（如果使用得当），它们可以帮助高效过滤等，当然，当使用并行流（）时，您可能能够更快地获得结果（通过使用更多线程）。但是对于某些整数数组上的直接简单计算，这些优势都不适用！

Answer 3

让我们简单得多。您正在获取Stream中的最大值和最小值。

IntStream提供了以下方法：

OptionalInt max（）
OptionalInt min（）

以下是如何使用它的快速方法：

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());

请注意，您得到的是optionant，因此应该检查空值，但只有当IntStream本身为空时才会发生这种情况。因此，您可以在读取数组之前检查它。

编辑：此解决方案是在问题之前提出的，包括显示重要部分是countHigh和countLow部分的返回。