So the only thing functional interfaces does is enable another syntax to implement object-calls, which in fact is much more shorter and readeble in some cases.
When I think about parts from functional paradigm in object-orientated languages, better performance and avoiding of side-effects comes to my mind. But if you work wich object-calls in functional interfaces, you will never gain this advantages.
So if you use the functional touch of java you have to take care about the functional implementation. Then you will gain this advantages.
Here is an example that shows that a functional implementation with native types is more performant that an object-orientated implementation. (Both in Java):
Object-Orientated
Setset = new HashSet<>(); for (int i = 0; i < 1000000; i++) { set.add(new AdditionInteger(i)); } Iterator it = set.iterator(); AdditionInteger z1 = it.next(); long start = System.currentTimeMillis(); for (int i = 1; i < 1000000; i++) { z1.add( it.next()); } long end = System.currentTimeMillis(); System.out.println(end - start); // tooks 30261 ms // What about itration it = set.iterator(); start = System.currentTimeMillis(); for (int i = 1; i < 1000000; i++) { it.next(); } end = System.currentTimeMillis(); System.out.println(end - start); // tooks 47 ms
Functional
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
i + (i + 1);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
// tooks 8301 ms
So the functional code just took a third of the time the object-orientated code needed.
The reason might be the object-calls and the handling of the value inside the object, where the add-method was called. In functional languages you also have a space where values are stores, especially when they are bound to variables. This is space is calles environment. The handling of variables and values are not included in this experiment.
