Question

我想编写一个Java函数，它将int[]，float[]或double[]作为输入。算法完全相同（某种标量积）。如何编写能够处理所有类型数值数组的单个函数？

Answer 1

在Java中没有简单的方法来处理这个问题。你可以：

使用包装类型（Integer[]，Float[]，Double[]）并使用Number[]作为参数。因为数组在Java中是协变的，所以可以工作：

public static void main(String[] args) {
    f(new Integer[]{1,2,3});
    f(new Float[]{1,2,3});
    f(new Double[]{1,2,3});
}

private static void f(Number[] numbers) {
    f[0].doubleValue();
}

请注意，此方法会显着增加内存消耗。

将int[]和float[]数组转换为double[]并一直使用双打。最好创建方法的重载版本，其中int[]和float[]仅执行转换并委托给实际的double[]实现。
我相信Scala可以无缝地处理这个问题，因为Java基元类型是Scala中的语义对象。

Answer 2

如果没有：

，则无法在Java中对此进行编码

单独编码每个案例，或
对阵列上的所有操作使用反射...这可能比最佳解决方案更加混乱，脆弱且速度慢一些。

int[] float[]和double[]的唯一常见超类型是Object，因此不可能使用多态来解决这些类型。同样，泛型要求type参数是引用类型，int，float和double不是引用类型。

您需要接受您将拥有重复的代码，或更改数组的表示形式;例如使用Integer[] / Float[] / Double[]或Number[]。

Answer 3

您可以编写一种方法来完成所有操作，但是，它不会像高效的那样可读。您必须在通用或有效解决方案之间做出选择。

public static void main(String... args) throws IOException {
    int[] nums = new int[10*1000 * 1000];
    {
        long start = System.nanoTime();
        product2(nums);
        long time = System.nanoTime() - start;
        System.out.printf("Took %.3f seconds to take the product of %,d ints using an int[].%n", time / 1e9, nums.length);
    }
    {
        long start = System.nanoTime();
        product(nums);
        long time = System.nanoTime() - start;
        System.out.printf("Took %.3f seconds to take the product of %,d ints using reflections.%n", time / 1e9, nums.length);
    }
}

public static double product(Object array) {
    double product = 1;
    for (int i = 0, n = Array.getLength(array); i < n; i++)
        product *= ((Number) Array.get(array, i)).doubleValue();
    return product;
}

public static double product2(int... nums) {
    double product = 1;
    for (int i = 0, n = nums.length; i < n; i++)
        product *= nums[i];
    return product;
}

打印

Took 0.016 seconds to take the product of 10,000,000 ints using an int[].
Took 0.849 seconds to take the product of 10,000,000 ints using reflections.

如果您只处理相对较小的阵列，那么通用但效率较低的解决方案可能足够快。

Answer 4

我看到两个选项：

1）您可以创建一个新类，它允许在构造函数中使用int []，float []，double []并保存它们。

2）你允许Object []并检查int / float / double。（你必须先转换它们）

Answer 5

使用java.lang.Number类型或Object参数类型。

有关详细信息，请参阅Bounded Type Parameters

Answer 6

class ArrayMath {
    private ArrayMath() {
    }

    public static <T extends Number> double ScalarProduct(T[] a, T[] b){
        double sum = 0;

        for(int i=0;i<a.length;++i){
            sum += a[i].doubleValue()*b[i].doubleValue();
        }
        return sum;
    }
}
class Sample {
    public static void main(String arg[]){
        Integer[] v1 = { 1, -10, 3, 9, 7, 99, -25 };
        Integer[] v2 = { 1, -10, 3, 9, 7, 99, -25 };
        double p_int = ArrayMath.ScalarProduct(v1, v2);
        Double[] v1_d = { 1.1, -10.5, 3.7, 9.98, 7.4, 9.9, -2.5 };
        Double[] v2_d = { 1.1, -10.5, 3.7, 9.98, 7.4, 9.9, -2.5 };
        Double p_double = ArrayMath.ScalarProduct(v1_d, v2_d);

        System.out.println("p_int：" + p_int);
        System.out.println("p_double：" + p_double);
    }
}

Answer 7

希望这会对你有所帮助..我已经测试了这段代码，它完成了你所要求的，如何实现这个逻辑是由你决定的！

public class MultiDataType {

    public static void main(String[] args) {

        int[] i = new int[2];
        float[] f = new float[2];
        double[] d = new double[2];
        String str = new String();

        handlingFunction(i);
        handlingFunction(f);
        handlingFunction(d);
        handlingFunction(str);
    }

    public static void handlingFunction(Object o) {
        String classType = null;
        if (o.getClass().getCanonicalName().equals("int[]")) {
            classType = "int[]";// Your handling code goes here
        } else if (o.getClass().getCanonicalName().equals("float[]")) {
            classType = "float[]";// Your handling code goes here
        } else if (o.getClass().getCanonicalName().equals("double[]")) {
            classType = "double[]";// Your handling code goes here
        }else classType = o.getClass().getCanonicalName();

        System.out.println("Object belongs to " + classType);
    }

}

<强>输出

Object belongs to int[]
Object belongs to float[]
Object belongs to double[]
Object belongs to java.lang.String

int []，float []或double []数组的Java函数

7 个答案: