Lambda 和通用方法

Question

我正在学习 Lambda，但遇到了一些我无法解决的问题。

原来我的代码是：

package Lambdas;

@FunctionalInterface
interface NumericFunc2 {
    <T extends Number> T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = (n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

但是，我的操作员旁边不断出现错误（<、-、/）。 PS：即使我将其更改为<T extends Double>，我也会遇到同样的错误。

现在，如果我通过添加参数类型来更改代码，我会收到错误提示“目标方法是通用的”：

即使我将其更改为 <T extends Double>，我也会遇到同样的错误。

package Lambdas;

@FunctionalInterface
interface NumericFunc2 {
    <T extends Number> T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = (Double n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

但是，如果我将类从非泛型更改为泛型，一切正常，就像下面的代码：

package Lambdas;

@FunctionalInterface
interface NumericFunc2<T extends Number>  {
    T func(T n);
}

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2<Double> smallestF = (n) -> {
            double result = 1;
            // Get absolute value of n.
            n = n < 0 ? -n : n;
            for (int i = 2; i <= n / i; i++)
                if ((n % i) == 0) {
                    result = i;
                    break;
                }
            return result;
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}

所以，我的问题是。我在代码的第一部分做什么？如何在非泛型类中正确使用具有泛型方法的 lambda？

Answer 1

答案是您不能对Number 对象执行这种数字运算。没有办法; 这与 lambdas 无关，而与 Number 抽象类无关，只是不提供这些功能。

在不知道Number 是什么类型的情况下，甚至没有任何方法可以获取Number 的绝对值。你看不到它是正还是负，你不能否定它，你不能加、减或乘。 唯一你可以用 Number 做的事情是将它转换成另一种原始类型，但你不能把它转换回来，你不能用它做数学。

Answer 2

根据JLS，泛型和lambda 不能一起工作。 This eclipse bug report 用一些代码示例讨论它。

为了让它工作，你必须回退到anonymous inner classes。 IE。你必须在你的函数周围写完整的new NumberFunc() {...} mambo-jambo。

我必须在方法主体中进行一些其他更改才能使其编译：

• result 是盒装的Double，所以我可以将其转换为T
• 在方法内部，我使用 n 的 doubleValue()，因为原始运算符不适用于 T extends Number。

放在一起：

class Lbd_488_NumericFunc_SelfTest {
    public static void main(String args[]) {
        // This block lambda returns the smallest positive factor of a value.
        NumericFunc2 smallestF = new NumericFunc2() {
            public <T extends Number> T func(T n) {
                Double result = 1d;
                // Get absolute value of n.
                double nAbs = n.doubleValue() < 0 ? -n.doubleValue() : n.doubleValue();
                for (int i = 2; i <= nAbs / i; i++)
                    if ((nAbs % i) == 0) {
                        result = (double) i;
                        break;
                    }
                return (T) result;
            }
        };
        System.out.println("Smallest factor of 12 is " + smallestF.func(12));
        System.out.println("Smallest factor of 11 is " + smallestF.func(11));
    }
}