La aplicación de deshumidificación bucle con un pequeño cambio en cada función

Kshitij Bajracharya:

Supongamos que tengo el siguiente fragmento de código que encuentra las sumas y productos de una gran variedad de matriz de enteros.

public class Foo {

    public static void main(String[] args) {
        int[][] numberLists = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        int[] sums = getListOfSums(numberLists);
        int[] products = getListOfProducts(numberLists);

        print(sums);
        System.out.println("----");
        print(products);
    }

    private static int[] getListOfSums(int[][] numberLists) {
        int[] sums = new int[3];
        for (int i = 0; i < 3; i++) {
            sums[i] = add(numberLists[i]);
        }
        return sums;
    }

    private static int[] getListOfProducts(int[][] numberLists) {
        int[] products = new int[3];
        for (int i = 0; i < 3; i++) {
            products[i] = multiply(numberLists[i]);
        }
        return products;
    }

    private static int add(int[] numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }

    private static int multiply(int[] numbers) {
        int product = 1;
        for (int number : numbers) {
            product *= number;
        }
        return product;
    }

    private static void print(int[] results) {
        for (int result : results) {
            System.out.println(result);
        }
    }

}

La salida es:

6
15
24
----
6
120
504

En las funciones, getListOfSumsy getListOfProducts, cada línea es la misma excepto la función de ser llamado, es decir, addy multiplyrespectivamente. ¿Hay una mejor manera de escribir esto para que el código no se repite? ¿Hay alguna manera de pasar funciones como argumentos?

El código no se ve horrible en este sencillo problema, pero cuando el problema se vuelve compleja con más de 10 líneas dentro del bucle y múltiples funciones con estructura similar, a continuación, el código no se ve limpio. ¿Hay alguna manera de superar este desastre?

Eran :

Se puede escribir un único método que acepta una Function<int[],Integer>y aplica esta función a las matrices de entrada:

private static int[] getListOfOperator(int[][] numberLists, Function<int[],Integer> operator) {
    int[] products = new int[3];
    for (int i = 0; i < 3; i++) {
        products[i] = operator.apply(numberLists[i]);
    }
    return products;
}

Y las Functionimplementaciones pueden tener este aspecto:

Function<int[],Integer> sum = Foo::add;
Function<int[],Integer> product = Foo::multiply;

Su mainllegarán a ser:

public static void main(String[] args) {
    int[][] numberLists = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int[] sums = getListOfOperator(numberLists,Foo::add);
    int[] products = getListOfOperator(numberLists,Foo::multiply);
    print(sums);
    System.out.println("----");
    print(products);
}