Thread: Jva 8 lambdas!

I get why lambda expressions are nice to have, but I'm skeptical of how big of a problem it really is. Until I see some statistics on how big of an advantage it is for java to have lambda expressions, I won't be convinced. Based on what I've read, it seems to just be a shorthand way of doing functional interfaces. Considering that functional interfaces are really not that verbose already, it seems like an unnecessary addition.

That being said, I do find myself using the shorthand if statement more than I expected when I learned about it, so maybe I'm just being obtuse.

I've seen examples of uses for them, but none that scream: this is why lambda expressions are so great.
It seems all the examples could be done with anonymous classes, which is quite easy to do...

For example:
No Lambda:

btn.setOnAction(new EventHandler<ActionEvent>() {
 
            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });

With Lambda:

btn.setOnAction(
          event -> System.out.println("Hello World!")
        );

Less verbose? Sure. Significant advantage? Not in my opinion.

Efficient for initially coding, but how efficient is it for debugging/code tracing?
I fear, based on the examples I've seen, that a widespread use of lambdas (as with most shortcuts) will make code less readable (compared to the "old" non-lambda way of doing things), which severely harms long-term efficiency.
This becomes a huge problem when we start seeing people try to nest shortcuts.

For example, which one of these would be easier to debug (ignore the stupid logic in these if/else statements, I just wrote a bunch of random crap)?
Shortcut If/Else:

int input = 1456;
int value = input%12==0 ? (input%4==0 ? 4 : (input%3==0 ? 3 : 2)) : (input%15==0 ? (input%5==0 ? 5 : (input%3==0 ? 3 : 15)) : input);

Normal If/Else:

int input = 1456;
int value = input;
if(input%12==0) {
	if(input%4==0) {
		value = 4;
	}
	else if(input%3==0) {
		value = 3;
	}
	else {
		value = 2;
	}
}
else if(input%15==0) {
	if(input%5==0) {
		value = 5;
	}
	else if(input%3==0) {
		value = 3;
	}
	else {
		value = 15;
	}
}

Sure, the shorthand way is more efficient and faster to type, but god have mercy on whatever poor SOB has to debug/maintain that code in the future. Ultimately, the "long way" of writing that logic may take much longer, but is FAR easier to manage.

The same principle applies to the lambda expressions. As with all shortcuts, it must be used responsibly, but probably won't be...

My 0.02 on lambda's: they add a function programming aspect to Java that has been missed for years, and can make development much easier in situations where function programming may be a better option (and mindset). This may not be in every application, but these situations can be encountered during development when the data model doesn't change relative to the frequency of the operations on the data. A simple example is a calculator - the data model virtually does not change (numbers). One may create a calculator to do basic math. Then, requirements need to be met to add some statistics (mean, standard deviation, etc...). Then requirements come in to do nested (find even numbers then count frequency, 2-level sorting, etc...) or recursive operations (prime numbers, sorting, ...). Taking a functional programming approach, in my view, is a much better approach to tackling this sort of development: quicker, cleaner, and more maintainable - no need to constantly implement an interface or method (and create instances of), the interface that defines behavior may need changing (or a new interface created) to adapt to different ways to manipulate the data (both of which may require full project refactoring), no need to explicitly define Collection loops (Streams do it for you - and in parallel if necessary).