为什么Java编译器不能从约束Iterable推断Iterable？扩展CharSequence>和（）->（迭代器）

Question

背景：我最近写了一个答案，建议编写以下代码：

Files.write(Paths.get("PostgradStudent.csv"),
        Arrays.stream(PGstudentArray).map(Object::toString).collect(Collectors.toList()),
        StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);

经过一番思考，我说：“我实际上不需要这里的列表，我只需要一个<代码>Iterable

Iterable<? extends CharSequence> iterable = () -> Arrays.stream(arr).map(Object::toString).iterator();

（对于这个问题，我将其提取到一个局部变量，我想在最后内联完成。）
很遗憾，如果没有其他类型提示，则无法编译：

error: incompatible types: bad return type in lambda expression
Iterable<? extends CharSequence> iterable = () -> Arrays.stream(arr).map(Object::toString).iterator();
                                                                                                   ^
    Iterator<String> cannot be converted to Iterator<CharSequence>

当然，添加一些类型提示可以实现这一点：

Iterable<? extends CharSequence> iterable2 = (Iterable<String>) () -> Arrays.stream(arr).map(Object::toString).iterator();
Iterable<? extends CharSequence> iterable3 = () -> Arrays.stream(arr).<CharSequence>map(Object::toString).iterator();

据我所知，Java编译器执行以下操作：

1. 它查看表达式的目标类型，它是可编辑的

有趣的是，如果我将lambda的目标更改为供应商：

Supplier<Iterator<? extends CharSequence>> supplier = () -> Arrays.stream(arr)
    .map(Object::toString)
    .iterator();

它会很好地编译。

现在的问题是：为什么javac不能推断出这个lambda的正确类型？

Answer 1

在阅读了另一个答案（这是绝对正确的）和一些咖啡后，这个bug中的解释似乎很符合逻辑。

这里有两种情况：显式lambda类型和隐式lambda类型。显式类型是：

Iterable<String> one = () -> Arrays.stream(arr).map(Object::toString).iterator();
Iterable<? extends CharSequence> iterable = one;

或者如OP的示例：

Iterable<? extends CharSequence> iterable2 = (Iterable<String>) () -> Arrays.stream(arr).map(Object::toString).iterator();

我们直接告诉编译器lambda表达式是哪种类型的：Iterable

在这种情况下，编译器只需做一件事：查看目标是否可分配给该类型；很容易找到，而且与lambdas本身没有太大关系。

另一种类型是隐式类型，当编译器必须推断类型时，这里的事情变得有点棘手。“棘手”的部分来自这样一个事实，即目标使用通配符，因此可以匹配多个选项。lambda可以被推断为无数种方式（当然是有限的，但只是为了证明一点）。

它可以从这样的东西开始，例如：

Iterator<? extends Serializable> iter = Arrays.stream(arr).map(Object::toString).iterator();

无论进一步做什么，这都将失败：CharSequence不会扩展可序列化的，但会扩展字符串；我们将无法分配Iterable

或者它可以从：

Iterator<? extends Comparable<? extends CharSequence>> iter = Arrays.stream(arr).map(Object::toString).iterator();

因此，理论上，编译器可以开始推断该类型，并逐一检查“特定”推断类型是否与目标匹配；但显然需要大量的工作；因此，没有这样做。

另一种方法要简单得多，“切掉”目标，从而将推理的可能性降到一个。一旦目标转换为：

Iterable<CharSequence> iterable...

编译器必须做的工作要简单得多。

顺便说一句，这不是我第一次在lambdas中看到隐式与显式类型逻辑。

Answer 2

您可以在此处找到一些解释：

在检查兼容性之前，必须将通配符参数化函数接口类型转换为函数类型（方法签名）。。。其工作原理如下：

Iterable<? extends CharSequence> becomes () -> Iterator<CharSequence>

因此，如果lambda表达式是隐式类型的，则LHS成为迭代器

Iterator<String> cannot be converted to Iterator<CharSequence>

JLS§18.5.3中也解释了这种行为。