Java 如何以通用方式使用算术运算减少基元数组？

我有这个方法：

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

公共静态long[]计算差分数组（long[]数组）{
long[]diffArray=new long[array.length-1]；
对于（int i=0；i

目前，它只接受

long[]

并返回

long[]

。但是我想在

int[]

上也使用同样的方法。我该怎么做

---

我已经读到Java泛型只对类对象起作用

每次都必须将int[]转换为long[]，您可以试试这个

公共静态void main（字符串[]args）{

int[]a1=新的int[]{1,2,3,4,5}；
Test1.computedDifferenceArray（Arrays.stream（a1）.mapToLong（i->i.toArray（））；
System.out.println（“56897”）；
}
公共静态Long[]计算差分数组（Long[]数组）{
Long[]diffArray=new Long[array.length-1]；
对于（int i=0；i

每次都必须将int[]转换为long[]，您可以试试这个

公共静态void main（字符串[]args）{

int[]a1=新的int[]{1,2,3,4,5}；
Test1.computedDifferenceArray（Arrays.stream（a1）.mapToLong（i->i.toArray（））；
System.out.println（“56897”）；
}
公共静态Long[]计算差分数组（Long[]数组）{
Long[]diffArray=new Long[array.length-1]；
对于（int i=0；i

实现您的需求的最佳方法是编写一个通用方法，并注入所需的行为以应用于阵列的成员—如果您愿意，这是策略模式的实现。通过引入streams，您可以非常优雅地完成这项工作，请查看您的代码以给定的方式重写如下：

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

import org.junit.Test；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.function.BiFunction；
导入静态junit.framework.TestCase.assertEquals；
//逻辑语境
类数组差异{
公共列表difStream（T[]输入，双功能操作）{
列表输出=新的ArrayList（）；
for（int i=0；i

---

正如我们所看到的，方法是不变的，我们从外部注入行为。出于测试目的，我使用了Math.substractExact（）方法，对于float和double，我编写了简单的方法。通过这种方式，代码是可扩展的，并且很容易在以后添加新的数据类型。

实现您的需求的最佳方法是编写一个通用方法，并注入所需的行为以应用于阵列的成员—如果您愿意，这是策略模式的实现。通过引入streams，您可以非常优雅地完成这项工作，请查看您的代码以给定的方式重写如下：

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

import org.junit.Test；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.function.BiFunction；
导入静态junit.framework.TestCase.assertEquals；
//逻辑语境
类数组差异{
公共列表difStream（T[]输入，双功能操作）{
列表输出=新的ArrayList（）；
for（int i=0；i