Как в Java выстрелить себе в ногу из лямбды и не промахнуться

Почему вы решили, что код работает одинаково, когда getClass() вызывается и когда не вызывается? Запустите такой код:

Integer x = 4242;
System.out.println(System.identityHashCode(x));

Выводит? Выводит. Значит, x — это реальный объект с идентичностью, верно? Верно. Значит, сколько мы Integer в коде объявим, столько объектов в куче и будет, верно? А вот и нет, вызов identityHashCode всё меняет. Без него объект мог бы скаляризоваться. Это как в квантовой физике: когда вы пытаетесь измерить систему, вы на неё своим измерением влияете, и система от этого изменяет квантовое состояние.

Я тут немного нафилософствовал, на самом деле отличие немного в другом. К созданному анонимному классу привязан класс-лоадер — это класс-лоадер внешнего класса. Но по факту класс ему не принадлежит, это просто для удобства сделано. В частности, к класс-лоадеру класс не привязан. То есть класс-лоадер не ссылается на эту лямбду (например, она может быть собрана сборщиком мусора независимо от класс-лоадера). И протекшн-домена у анонимного класса нет. Разницу легко прощупать на следующем примере:

public class Test {
  public static void main(String[] args) throws Exception {
    Runnable r = new Runnable() {public void run(){}};//() -> {};
    System.out.println(r.getClass().getClassLoader());
    System.out.println(r.getClass().getName());
    System.out.println(Class.forName(r.getClass().getName(), false, r.getClass().getClassLoader()));
  }
}

Обычный джавовый анонимный класс вы легко можете загрузить через класс-лоадер по имени. Анонимный класс JVM по имени никогда не загружается (замените анонимный класс на лямбду и получите ClassNotFoundException.

Effectively final не мешает одной и той же лямбде при разных вызовах захватить новое значение.

Supplier<String> get(String x) { return () -> x; }

Supplier<String> s1 = get("a");
Supplier<String> s2 = get("b");

Здесь лямбда в коде ровно одна и рантайм-представление под неё одно сгенерируется. Но объекта будет два (s1 != s2), потому что где-то же надо хранить эти "a" и "b" (как раз в синтетическом поле разных экземпляров рантайм-представления).

Настоящих замыканий нет вовсе не поэтому, а из-за модели памяти. И это прекрасно, что их нет.

Как вы себе представляете технически использование одного и того же объекта?

Допустим, есть такой метод:

Callable<Integer> const(int v) {
  return () -> v;
}

вызываем его:

Callable<Integer> a = const(1), b = const(2);

Вы утверждаете:

при любом последующем вызове работать будет все тот же один объект, ничего нового создаваться не будет

По-вашему, теперь должно получиться вот так?

assert (a == b);
assert (a.call().equals(1));
assert (b.call().equals(2));

Вам не кажется, что это невозможно?