Java lambda返回lambda

Question

我正试图做一件在新JDK似乎是相对基本的事情

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

public class so1 {
   public static void main() {
      List<Number> l = new ArrayList<>(Arrays.asList(1, 2, 3));
      List<Callable<Object>> checks = l.stream().
               map(n -> (Callable<Object>) () -> {
                  System.out.println(n);
                  return null;
               }).
               collect(Collectors.toList());
   }
}

它获取一个数字列表并生成一个可以将它们打印出来的函数列表。然而，Callable的显式强制执行似乎是多余的。对我和IntelliJ来说似乎是这样。我们都同意这也应该有效：

List<Callable<Object>> checks = l.stream().
       map(n -> () -> {
          System.out.println(n);
          return null;
       }).
       collect(Collectors.toList());

但是，我收到一个错误：

so1.java:10: error: incompatible types: cannot infer type-variable(s) R
      List<Callable<Object>> checks = l.stream().map(n -> () -> {System.out.println(n); return null;}).collect(Collectors.toList());
                                                    ^
    (argument mismatch; bad return type in lambda expression
      Object is not a functional interface)
  where R,T are type-variables:
    R extends Object declared in method <R>map(Function<? super T,? extends R>)
    T extends Object declared in interface Stream
1 error

Answer 1

我还没有深入研究类型推理如何与lambda一起工作的确切规则。不过，从一般的语言设计角度来看，并不总是可以编写语言规则来让编译器弄清楚我们认为它应该弄清楚的一切。我曾是Ada语言编译器的编译器维护者，我熟悉那里的许多语言设计问题。Ada在很多情况下使用类型推理（如果不查看包含构造的整个表达式，就无法确定构造的类型，我认为这个Javalambda表达式也是这种情况）。有一些语言规则会导致编译器拒绝某些表达式为模棱两可，而在理论上，实际上只有一种可能的解释。如果我没记错的话，一个原因是有人发现了这样一种情况，即让编译器找出正确解释的规则要求编译器使17通过表达式才能正确解释它。

因此，虽然我们可能认为编译器“应该”能够在特定情况下找出一些东西，但这显然是不可行的。

Answer 2

我遇到了同样的问题，并且能够通过显式指定泛型类型参数来映射它，如下所示：

List<Callable<Object>> checks = l.stream().
   <Callable<Object>>map(n -> () -> {
      System.out.println(n); 
      return null;
   }).
   collect(Collectors.toList());

Answer 3

您遇到了Java的一个限制

在这里，< code>l.stream()。地图(n -

如果目标类型是已知的，很容易证明嵌套的lambda表达式是有效的，例如

static <T> Function<T,Callable<Object>> toCallable() {
    return n -> () -> {
        System.out.println(n); 
        return null;
    };
}

工作没有问题，你可以用它来解决你原来的问题

List<Callable<Object>> checks = l.stream()
    .map(toCallable()).collect(Collectors.toList());

您还可以通过引入一个帮助器方法来解决此问题，该方法将第一个表达式的角色从方法接收器更改为参数

// turns the Stream s from receiver to a parameter
static <T, R, A> R collect(Stream<T> s, Collector<? super T, A, R> collector) {
    return s.collect(collector);
}

并将原始表达式重写为

List<Callable<Object>> checks = collect(l.stream().map(
    n -> () -> {
        System.out.println(n); 
        return null;
    }), Collectors.toList());

这不会降低代码的复杂度，但可以毫无问题地编译。对我来说，这是似曾相识。当Java