lambdas中隐含的匿名类型

Question

这个答案使用了流，但这个问题不是关于流的，因为这个匿名类型构造可以在其他上下文中使用，即：

String s = "Digging into Java's intricacies";

Optional.of(new Object() { String field = s; })
    .map(anonymous -> anonymous.field) // anonymous implied type 
    .ifPresent(System.out::println);

令我惊讶的是，这编译并打印了预期的输出。

注意：我很清楚，自古以来，就有可能构造一个匿名的内部类，并按如下方式使用它的成员：

int result = new Object() { int incr(int i) {return i + 1; } }.incr(3);
System.out.println(result); // 4

public class Person {
    Long id;
    String name, lastName;
    // getters, setters, hashCode, equals...
}

List<Person> people = ...;

并且我需要在某个存储库中存储Person实例的JSON表示，为此，我需要每个Person实例以及每个PersonID的JSON字符串：

public static String toJson(Object obj) {
    String json = ...; // serialize obj with some JSON lib 
    return json;
}        

people.stream()
    .map(person -> toJson(person))
    .forEach(json -> repository.add(ID, json)); // where's the ID?

在本例中，我丢失了person.id字段，因为我已经将每个人转换为其对应的json字符串。

为了避免这种情况，我看到许多人使用某种holder类，或pair，甚至tuple，或者仅仅使用abstractmap.simpleentry:

people.stream()
    .map(p -> new Pair<Long, String>(p.getId(), toJson(p)))
    .forEach(pair -> repository.add(pair.getLeft(), pair.getRight()));

虽然这对于这个简单的示例来说已经足够好了，但它仍然需要一个泛型pair类的存在。如果我们需要在流中传播3个值，我想我们可以使用tuple3类等。使用数组也是一种选择，但是它不是类型安全的，除非所有的值都是相同的类型。

因此，使用隐含的匿名类型，上面相同的代码可以重写如下：

people.stream()
    .map(p -> new Object() { Long id = p.getId(); String json = toJson(p); })
    .forEach(it -> repository.add(it.id, it.json));

这是魔法！现在，我们可以拥有所需的任意多个字段，同时还保留了类型安全性。

String s = "Digging into Java's intricacies";

Optional<Object> optional = Optional.of(new Object() { String field = s; });

optional.map(anonymous -> anonymous.field)
    .ifPresent(System.out::println);

Error: java: cannot find symbol
  symbol:   variable field
  location: variable anonymous of type java.lang.Object

这是意料之中的，因为object类中没有名为field的成员。

所以我想知道：

• 这是在什么地方记录的吗，还是在JLS中有关于这一点的内容？
• 这有什么限制（如果有的话）？
• 这样编写代码实际上安全吗？
• 有没有速记语法，或者这是我们所能做到的最好的语法？

Answer 1

JLS中没有提到这种用法，但是，当然，规范并不是通过列举编程语言提供的所有可能性来工作的。相反，您必须应用关于类型的正式规则，它们对匿名类型没有例外，换句话说，规范在任何时候都没有说，在匿名类的情况下，表达式的类型必须回到命名的超级类型。

诚然，在规范的深处，我可以忽略这样一个语句，但对我来说，关于匿名类型的唯一限制源于它们的匿名性质，即要求通过名称引用类型的每一种语言构造都不能直接使用该类型，因此您必须选择一个超类型，这看起来总是很自然的。

因此，如果表达式new Object（）{String field；}的类型是包含字段“field”的匿名类型，那么不仅访问new Object（）{String field；}.field可以工作，而且collections.singletonList（new Object（）{String field；}）.get(0).field也可以工作，除非有显式规则禁止，并且一致，否则lambda表达式同样适用。

从Java ；10开始，您可以使用var声明其类型是从初始值设定项推断出来的局部变量。这样，您现在就可以声明任意的局部变量，而不仅仅是lambda参数，它们的类型是匿名类。例如，以下工作

var obj = new Object() { int i = 42; String s = "blah"; };
obj.i += 10;
System.out.println(obj.s);

同样,我们可以让你的问题的例子起作用：

var optional = Optional.of(new Object() { String field = s; });
optional.map(anonymous -> anonymous.field).ifPresent(System.out::println);

在这种情况下，我们可以参考显示类似示例的规范，该示例表明这不是一个疏忽，而是有意为之的行为：

var d = new Object() {};  // d has the type of the anonymous class

另一个暗示了变量可能具有不可表示类型的一般可能性：

var e = (CharSequence & Comparable<String>) "x";
                          // e has type CharSequence & Comparable<String>