在Java 8中使用嵌套的for循环

Question

I have below code where I am using nested for loops and I have some condition that breaks the inner for loop, and this improves the performance of this code.

public static int getMaxValue(List<Integer> list) {
    int result = -1;
    for(int i=0; i<list.size(); i++) {
        for(int j=i+1; j<list.size(); j++) {
            if(list.get(j) - list.get(i) <= 0) break;
            if(list.get(j) - list.get(i) > result) {
                result = list.get(j) - list.get(i);
            }
        }
    }
    return result;
}

Now how can I use Java 8 streams to do the same logic? I have come up with below code:

public static int getMaxValue(List<Integer> list) {
    int[] result = { -1 };
    IntStream.range(0, list.size()).forEach(i -> {
        IntStream.range(i + 1, list.size()).forEach(j -> {
            if(list.get(j) - list.get(i) <= 0) return;

            if(list.get(j) - list.get(i) > result[0]) {
                result[0] = list.get(j) - list.get(i);
            }
        });
    });
    return result[0];
}

Here I cannot use a break statement in java streams, so I have used return statement, but that still runs the inner loop, as it will not break it the performance is not improved.

Answer 1

If I understand your code, you're trying to find the maximum pairwise difference between any two elements in the input list. You can do that with IntSummaryStatistics :

public static int getMaxValue(List<Integer> list) {
    IntSummaryStatistics stats = list.stream()
        .mapToInt(Integer::intValue)
        .summaryStatistics();
    return stats.getMax() - stats.getMin();
}

This is an O(n) operation, with O(1) auxiliary storage. There is still no need for an O(n²) operation. Ultimately, breaking out of a loop early is an optimization, but not a very effective one -- finding an approach with a lower asymptotic cost will always be more effective than just breaking out of a loop early.

Answer 2

If your intention is to find the maximum value, you could just do:

list.stream()
     .mapToInt(Integer::intValue)
     .max();

It will return an OptionalInt which will be empty of your list is empty.

Otherwise not sure what you want to achieve with your code...

UPDATE After clarification from the Op.

Create a small class called MinMax which stores min and max , like:

public class MinMax {
  private final int min;
  private final int max;

  private MinMax(int min, int max) {
    this.min = min;
    this.max = max;
  }

  public int getDifference() {
    return this.max - this.min;
  }

  public MinMax accept(int element) {
    int newMin = element < min ? element : min;
    int newMax = element > max ? element : max;

    if (newMin != min || newMax != max) {
      return new MinMax(newMin, newMax);
    } else {
      return this;
    }
  }

  public static MinMax seed() {
    return new MinMax(Integer.MAX_VALUE, Integer.MIN_VALUE);
  }
}

This new class takes care of keeping track of both minimum and maximum. Now you could do something like:

int result = list.stream() 
                 .reduce(MinMax.seed(), MinMax::accept())
                 .getDifference();

Answer 3

Java stream offers a special functionality for this use case which is findFirst, it will stop iteration over the collection and return immediately. Check this https://www.google.ae/amp/s/www.geeksforgeeks.org/stream-findfirst-java-examples/amp/

Moreover you can apply your test condition with filter, you'll use filter to check and findFirst to stop. This is in general to do what you asked for.