lambdaj doesn't really offer lambda expressions
It is right.
[lambdaj] provides some functions, such as closing
If by this you mean "it provides closure," no, it is not. Closing cannot exist without a lambda expression; in fact, this is a special case of lambda expression, which is most in demand for implementation.
Unfortunately, the LambdaJ project documentation is quite misleading when applying the term “close” to something that doesn't fit. Example from the Closures wiki page:
Closure println = closure(); { of(System.out).println(var(String.class)); }
The following explanation follows:
In particular, the var() method associates a free variable of type String with a closure.
This statement is simply incorrect: variable binding does not occur at all, not to mention a free variable. The construction leads to something resembling a unary function that expects a String argument. (Well, what he actually expects is Object , but will work at runtime if not String passed.)
On the other hand, the call of of() in the example goes a little towards local capture of variables. We can say that the argument passed to of() is captured by the object that it returns. However, we cannot refer to it in any additional syntax; this is just the implicit purpose of the method call. This is far from complete closure.
I am wondering what 1.8 lambda expressions can lead to a Java project that lambdaj cannot. Is it just a performance issue with support for anonymous functions?
Since LambdaJ does not provide the ability to write anonymous functions, the question is technically incontrovertible. However, be sure that closing Java 8 will outperform LambdaJ based on usecase-by-usecase, because LambdaJ is based on reflection, while closing Java does not need it at all.
Will there be expressions like lambdaj memory manipulation functions in 1.8?
Absolutely, and the support is very serious and complete. There are other functions, and the functions are more complex. The features of LamdaJ are overshadowed by what is available pre-built in Java 8. Check out the Streams API .
One of the main goals of Streams API design has never been realized by LambdaJ: automatic parallelization of processing. Of course, FP-oriented collection processing looks better than a strong idiom, but it is much more than it looks: this is a fundamental change. This is Java's bet on the future of computing, where the only way to improve performance is to use more parallel processing threads.