Uso de bucles for anidados en Java 8

alumno:

Tengo debajo de código en la que estoy utilizando bucles for anidados y tengo alguna condición que rompe el interior de bucle, y esto mejora el rendimiento de este código.

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

Ahora, ¿cómo puedo usar Java 8 flujos de hacer la misma lógica? He llegado con más adelante código:

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

Aquí no puedo usar una breakdeclaración en corrientes Java, por lo que he utilizado returndeclaración, pero que todavía se ejecuta el bucle interno, ya que no lo romperá el rendimiento no mejora.

Daniel Pryden :

Si entiendo su código, que está tratando de encontrar la diferencia máxima de pares entre dos elementos en la lista de entrada. Usted puede hacer eso con IntSummaryStatistics:

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

Esta es una operación O (n), con O (1) de almacenamiento auxiliar. Todavía no hay una necesidad de un O (N ²) operación. En última instancia, salir de un bucle temprana es una optimización, pero no muy eficaz - la búsqueda de una aproximación asintótica con un coste menor será siempre más eficaz que simplemente salir de un bucle antes de tiempo.