为什么lambda表达式不能被解引用？ import java.util.*； 类TreeMapDemo { 公共静态void main（字符串参数[]） { 比较器c1=（str1，str2）->0； 比较器c2=（str1，str2）->1； TreeMap tm1=新的TreeMap（c1.然后比较（c2））； //工作正常 TreeMap tm2=新的TreeMap（（str1，str2）->0。然后比较（（str1，str2）->1）； //错误：此处不需要Lambda表达式 //不能取消引用 } }

我的问题是：

如果

c1=（str1，str2）->0和
c2=（str1，str2）->1

那为什么

c1。然后比较（c2）工作正常且

（（str1，str2）->0）。然后比较（（str1，str2）->1）
不是吗？
Java依赖lambda表达式的上下文来确定其类型。将lambda赋值给变量或将其作为方法参数传递可提供足够的上下文，但在lambda上调用方法（如
thenComparing（）
）根本无法提供有用的上下文

这应该起作用：

import java.util.*;

class TreeMapDemo
{
    public static void main(String args[])
    {
        Comparator <String> c1 = (str1, str2) -> 0;

        Comparator <String> c2 = (str1, str2) -> 1;

        TreeMap <String, Double> tm1 = new TreeMap(c1.thenComparing(c2));
        //Working fine

        TreeMap <String, Double> tm2 = new TreeMap(((str1, str2) -> 0).thenComparing((str1, str2) -> 1));
        //Error: Lambda expression not expected here
        //<none> can not be dereferenced
    }
}

比较器c1=（str1，str2）->0；
TreeMap tm2=新的TreeMap（c1.然后比较（（str1，str2）->1））；

更详细的信息：

lambda表达式的计算结果是实现某个函数接口的类型的对象，Java依赖于表达式出现的上下文来确定该函数接口是哪个。在第二种情况下，构造函数参数不是lambda的上下文；调用
thenComparing（）
的操作是无效的。构造函数参数是该方法的返回值。但是，在Java能够确定有关
然后比较（）
的任何内容之前，它需要知道调用它的对象的类型。类型通知方法，而不是相反

Java不能从参数类型向后工作到所需的lambda类型，因为可能有任意数量的函数接口可以工作。Java不能假定所需的接口在标准库中。
Java依赖lambda表达式的上下文来确定其类型。将lambda赋值给变量或将其作为方法参数传递可提供足够的上下文，但在lambda上调用方法（如
thenComparing（）
）根本无法提供有用的上下文

这应该起作用：

import java.util.*;

class TreeMapDemo
{
    public static void main(String args[])
    {
        Comparator <String> c1 = (str1, str2) -> 0;

        Comparator <String> c2 = (str1, str2) -> 1;

        TreeMap <String, Double> tm1 = new TreeMap(c1.thenComparing(c2));
        //Working fine

        TreeMap <String, Double> tm2 = new TreeMap(((str1, str2) -> 0).thenComparing((str1, str2) -> 1));
        //Error: Lambda expression not expected here
        //<none> can not be dereferenced
    }
}

比较器c1=（str1，str2）->0；
TreeMap tm2=新的TreeMap（c1.然后比较（（str1，str2）->1））；

更详细的信息：

lambda表达式的计算结果是实现某个函数接口的类型的对象，Java依赖于表达式出现的上下文来确定该函数接口是哪个。在第二种情况下，构造函数参数不是lambda的上下文；调用
thenComparing（）
的操作是无效的。构造函数参数是该方法的返回值。但是，在Java能够确定有关
然后比较（）
的任何内容之前，它需要知道调用它的对象的类型。类型通知方法，而不是相反

Java不能从参数类型向后工作到所需的lambda类型，因为可能有任意数量的函数接口可以工作。Java不能假定所需的接口位于标准库中。
Lambda表达式必须以特定类型为目标

Comparator <String> c1 = (str1, str2) -> 0;
TreeMap <String, Double> tm2 = new TreeMap(c1.thenComparing((str1, str2) -> 1));

是正常的，因为已知
c1
的类型

本身
（str1，str2）->0
是不明确的

比如说

c1 = (str1, str2) -> 0;

BiFunction x=（str1，str2）->0；

这也有道理

要使其具体化，请看这个示例

BiFunction<String, String, Integer> x = (str1, str2) -> 0;

公共接口Foo扩展了双功能{
默认比较器（比较器比较器）{
返回String.CASE\u不区分大小写\u顺序；
}
}
公共静态void main（字符串[]args）{
Foo Foo=（str1，str2）->0；//重写双函数的唯一方法
TreeMap TreeMap=newtreemap（foo.then比较（（str1，str2）->1））；
}

这编译得非常好。所以如果我们只是写

public interface Foo extends BiFunction<String, String, Integer> {
    default Comparator<String> thenComparing(Comparator<String> comparator) {
        return String.CASE_INSENSITIVE_ORDER;
    }
}

public static void main(String[] args) {
    Foo foo = (str1, str2) -> 0;        // overriding the sole method of BiFunction
    TreeMap<String, Double> treeMap = new TreeMap<>(foo.thenComparing((str1, str2) -> 1));
}

newtreemap（（str1，str2）->0），然后比较（（str1，str2）->1）；

编译器无法知道
（str1，str2）->0是
Foo
还是
比较器
。推理不会以这种方式反向工作。
Lambda表达式必须以特定类型为目标

Comparator <String> c1 = (str1, str2) -> 0;
TreeMap <String, Double> tm2 = new TreeMap(c1.thenComparing((str1, str2) -> 1));

是正常的，因为已知
c1
的类型

本身
（str1，str2）->0
是不明确的

比如说

c1 = (str1, str2) -> 0;

BiFunction x=（str1，str2）->0；

这也有道理

要使其具体化，请看这个示例

BiFunction<String, String, Integer> x = (str1, str2) -> 0;

公共接口Foo扩展了双功能{
默认比较器（比较器比较器）{
返回String.CASE\u不区分大小写\u顺序；
}
}
公共静态void main（字符串[]args）{
Foo Foo=（str1，str2）->0；//重写双函数的唯一方法
TreeMap TreeMap=newtreemap（foo.then比较（（str1，str2）->1））；
}

这编译得非常好。所以如果我们只是写

public interface Foo extends BiFunction<String, String, Integer> {
    default Comparator<String> thenComparing(Comparator<String> comparator) {
        return String.CASE_INSENSITIVE_ORDER;
    }
}

public static void main(String[] args) {
    Foo foo = (str1, str2) -> 0;        // overriding the sole method of BiFunction
    TreeMap<String, Double> treeMap = new TreeMap<>(foo.thenComparing((str1, str2) -> 1));
}

newtreemap（（str1，str2）->0），然后比较（（str1，str2）->1）；

编译器无法知道
（str1，str2）->0是
Foo
还是
比较器
。推理不会以这种方式反向工作。
这是Java中类型推理的一个限制。
首先，使用原始类型，比较器将解析为
比较器
，而不是
比较器

TreeMap tm1=新的TreeMap（（str1，str2）->0）；//不起作用

在哪里

TreeMap <String, Double> tm1 = new TreeMap((str1, str2) -> 0);// wouldn't work

TreeMap tm1=新的TreeMap（（str1，str2）->0）；//作品

现在，在类型被推断之前，不能对其调用特定方法

TreeMap <String, Double> tm1 = new TreeMap<>((str1, str2) -> 0);// works

比较器c1=（（str1，