问如何以通用的方式使用算术运算来缩减基元数组？

EN

    int[] a1=new int[] {1,2,3,4,5};
    Test1.computeDifferenceArray( Arrays.stream(a1).mapToLong(i -> i).toArray());
    System.out.println("56897");
}

public static Long[] computeDifferenceArray(long[] array) {
    Long[] diffArray = new Long[array.length - 1];
    for (int i = 0; i < diffArray.length; i++) {
        diffArray[i] = array[i + 1] - array[i];
    }

    return diffArray;
}

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;

import static junit.framework.TestCase.assertEquals;

// The logic context
class ArrayDifference {
    public <T> List<T> difStream(T[] input, BiFunction<T,T,T> operation) {
        List<T> output = new ArrayList<>();

        for (int i=0; i < input.length-1; i++) {
            output.add(operation.apply(input[i], input[i+1]));
        }

        return output;
   }
}

// additional reducing functions
class Reducers {
    static float substract(float f1, float f2) {
        return f1-f2;
    }

    static double substract(double d1, double d2) {
        return d1-d2;
    }
}

public class ArrayDifferenceTest {

    ArrayDifference arraySubstracter = new ArrayDifference();

    @Test
    public void test_integer() {
        Integer[] input = new Integer[]{Integer.valueOf(1), 
Integer.valueOf(2), Integer.valueOf(3)};
        List<Integer> expectedResult = Arrays.asList(-1,-1);

        // here you can see how it is called for integer
        List<Integer> result = arraySubstracter.difStream(input, Math::subtractExact);

        assertEquals(expectedResult, result);
    }

    @Test
    public void test_long() {
        Long[] input = new Long[]{Long.valueOf(1), Long.valueOf(2), Long.valueOf(3)};
        List<Long> expectedResult = Arrays.asList(-1L,-1L);;

        // here you can see how it is called for long
        List<Long> result = arraySubstracter.difStream(input, Math::subtractExact);

        assertEquals(expectedResult, result);
    }

    @Test
    public void test_double() {
        Double[] input = new Double[]{Double.valueOf(1), Double.valueOf(2), Double.valueOf(3)}
        List<Double> expectedResult = Arrays.asList(-1D,-1D);

        // here you can see how it is called for double
        List<Double> result = arraySubstracter.difStream(input, Reducers::substract);

        assertEquals(expectedResult, result);
    }


    @Test
    public void test_float() {
        Float[] input = {Float.valueOf(1F), Float.valueOf(2F), Float.valueOf(3F)};
        List<Float> expectedResult = Arrays.asList(-1F, -1F);

        // here you can see how it is called for float
        List<Float> result = arraySubstracter.difStream(input, Reducers::substract);

        assertEquals(expectedResult, result);
    }
}