Category Archives: Lambda Expressions

Unknown's avatar Namal Fernando 10:25 pm on 11th May 2020
Tags: , references   

Passing a variable (an int or some immutable type) to a Lambda block

When passing a variable (an int or some immutable type) to a block of the lambda expression, if it is..

  1. An instance variable and lambda block is also inside a instance method – can mutate
  2. A static variable – can mutate
  3. A local variable – can’t mutate

Root cause :

Here, Java would need to capture a reference, and then modify the value through it.
And JVM lacks mechanisms of constructing references to local variables.
That’s why #3 doesn’t work.

Java does not have this problem when you use an array, because arrays are reference objects.
Because Java can capture array reference that never changes, and use that non-changing reference to mutate the object.
Java arrays are mutable.

And a reference to the static variable is readily available, so there is no problem with capturing it. That’s why #2 works.

And Lambda modifies the variable through this object. that’s why #1 works

References :

  • https://stackoverflow.com/questions/40862845/java-8-lambda-variable-scope
  • https://www.theserverside.com/blog/Coffee-Talk-Java-News-Stories-and-Opinions/Benefits-of-lambda-expressions-in-Java-makes-the-move-to-a-newer-JDK-worthwhile

#lambda, #references

Unknown's avatar Namal Fernando 10:15 pm on 11th May 2020
Tags: , ,   

Local variables referenced from a lambda expression must be final or effectively final

Local variables referenced from a lambda expression must be final or effectively final

effectively final :

  • A variable or parameter whose value is never changed after it is initialized
  • If a reference is not changed it is effectively final even if the object referenced is changed.
  • Any variable that is assigned once and only once, is “effectively final”.

In simple terms :

Imagine adding the final modifier to a variable declaration. If, with this change, the program continues to behave in the same way, both at compile time and at run time, then that variable is effectively final.

It looks like it is exact similar way. But only difference is no final keyword.

eg :

these are final

final int variable = 123;

final int number;
number = 23;

this is effective final

int variable = 123;

int number;
number = 34;

Fruther discussion :

Variables inside anonymous class must be final in outer class

#effectively-final, #final, #lambda

Unknown's avatar Namal Fernando 10:01 pm on 11th May 2020
Tags: Collection, , , Iteration, , List, Map   

Iterating Collections (Map / List) using Lambda

  1. Classical way of iterating a map

Syntax : 

for(Map.Entry entry : map.entrySet){
    entry.getKey()
    entry.getValue()

example : 

private static void oldMapIter(Map map) {
	for(Map.Entry entry : map.entrySet()) {
		System.out.println(entry.getKey() + ":" + entry.getValue());
	}
}

We can simply use Lambda expressions to get this done.

private static void newMapIter(Map map) {
	// map.forEach((k,v)->System.out.println("newMapIter()."+k+" : " + v ));
	map.forEach((k,v)->{
		System.out.println(k+" : "+v );
	});
}

2. Classical way of iterating a map

private static void oldCollection(List list) {
	for (String string : list) {
		System.out.println(string);
	}
}

Iterate using Lambda expression : 

private static void newCollection(List list) {
	// list.forEach(item -> System.out.println("newCollection().item : " + item));
	list.forEach(item -> {
		System.out.println(item);
	});
}

But there are some downsides of using Lambda in forEach. One of them is restrictions to use variables inside the block. Because to mutate (increase the index etc) a variable inside the Lambda forEach block, it should be final or effectively final.

Further readiings :

  1. Passing a variable (an int or some immutable type) to a lambda block
  2. Local variables referenced from a lambda expression must be final or effectively final

#collection, #effectively-final, #final, #iteration, #lambda, #list, #map