Java Lambda Referencing Enclosing Object: Replace with Private Static Class?

Question

A Java lambda referencing an element from its enclosing scope holds a reference to its enclosing object. A contrived example, with lambda holding ref to MyClass:

class MyClass {
  final String foo = "foo";
  public Consumer<String> getFn() {
    return bar -> System.out.println(bar + foo);
  }
}

This is problematic if the lifetime of the lambda is long; then we've got a ref to MyClass that is long-lived, when it would have otherwise gone out of scope. Here we can optimize by replacing the lambda with a private static class, so that we're only holding a reference to the String we need rather than to the entire class:

class MyClass {

  private static class PrintConsumer implements Consumer<String> {

    String foo;

    PrintConsumer(String foo) {
      this.foo = foo;
    }

    @Override
    public void accept(String bar) {
      System.out.println(bar + foo);
    }
  }

  final String foo = "foo";

  public Consumer<String> getFn() {
    return new PrintConsumer(foo);
  }
}

Unfortunately this is super verbose and destroys the nice syntax we get from using (effectively final) variables from enclosing scope in lambdas. Is this technically optimal? Is there always a tradeoff here between nice syntax and the possibility of keeping a ref longer than necessary?

Use C++ en.cppreference.com/w/cpp/language/lambda#Lambda_capture — user234461
– user234461, Commented Mar 23, 2016 at 19:53
I think your assumption is incorrect. The lambda does not hold a reference to the MyClass, only to the string. — Paul Boddington
– Paul Boddington, Commented Mar 23, 2016 at 19:55

Lukas Eder · Accepted Answer · 2016-04-13 20:01:59Z

15

Assign your member to a local variable first:

class MyClass {
  final String foo = "foo";
  private Consumer<String> getFn() {
    String localFoo = foo;
    return bar -> System.out.println(bar + localFoo);
  }
}

Now, the lambda only captures local variables inside of getFn(). MyClass.this is no longer captured.

Another option, slightly more verbose, delegate to a helper method:

class MyClass {
  final String foo = "foo";
  private Consumer<String> getFn() {
    return getFn(foo);
  }
  private static Consumer<String> getFn(String localFoo) {
    return bar -> System.out.println(bar + localFoo);
  }
}

edited Apr 13, 2016 at 20:01

answered Mar 23, 2016 at 19:54

Lukas Eder

223k138 gold badges731 silver badges1.6k bronze badges

Sign up to request clarification or add additional context in comments.

10 Comments

Lukas Eder Over a year ago

@AR.3: foo is a member reference from within the lambda. It needs to be resolved every time the lambda is invoked. For instance, it could be null if the lambda is invoked from the initialiser prior to foo being initialised. It could be changed again because of some reflection magic.

Lukas Eder Over a year ago

@srborlongan: I don't see any disadvantages, except, perhaps, readability? Higher order lambdas aren't a very common thing (yet)

Holger Over a year ago

@AR.3: When the lambda expression accesses MyClass.foo directly, it does use the compile-time constant rather than actually reading the field. The possibility of the field being not initialized yet or the presence of Reflection magic is never considered in Java. However, it still captures this, maybe to follow a certain rule like that any instance field access mandates the capturing of this, however, I can’t find that part inside the Java Language Specification.

Holger Over a year ago

@Lukas Eder: when localFoo is declared final, the field foo will never be read at runtime. Instead, the lambda expression will directly use "foo", regardless of what foo really contains when you invoke getFn() (speaking of the first solution, of course). Even without declaring localFoo as final, it will be directly initialized with "foo", not actually reading foo.

Holger Over a year ago

I’m not judging whether it is relevant to this specific question (though it’s worth noting that the behavior might be different for the question as-written compared to a possibly different real-life code). However, AR3 brought this up in the first comment, and there was a comment addressing it needing a correction. I only noticed afterwards that AR.3 opened a new specific question regarding that and added a more complex answer there…

|

srborlongan · Accepted Answer · 2016-03-24 02:30:01Z

1

A combination of Lukas Eder's local-final-variable and helper-method-delegation solutions:

class MyClass {
  final String foo = "foo";
  private Consumer<String> getFn() {
    return apply(
      foo,
      localFoo -> bar -> System.out.println(bar + localFoo)
    );
  }
  private static <IN, OUT> OUT apply(
    final IN in,
    final Function<IN, OUT> function
  ) {
    return function.apply(in);
  }
}

answered Mar 24, 2016 at 2:30

srborlongan

4,5994 gold badges28 silver badges33 bronze badges

Collectives™ on Stack Overflow

Java Lambda Referencing Enclosing Object: Replace with Private Static Class?

2 Answers 2

Assign your member to a local variable first:

Another option, slightly more verbose, delegate to a helper method:

10 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Assign your member to a local variable first:

Another option, slightly more verbose, delegate to a helper method:

10 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related