Java 8 Lambda vs LambdaJ vs Guava vs Iterative approach

In the middle of 2013, Java 8 comes out with a lambda expression implementation. Lambda expressions provide ample opportunities for application of functional programming style. True, the functional style can be used today in JDK 7, 6 or 5 using the LambdaJ and Guava libraries.

	Iterative	Lambdaj	JDK 8 lambda	Guava
Print all brands	79	472 *	113	79
Select all sales of a Ferrari	25	146	44	31
Find buys of youngest person	1,209	1,775	1,242	1.218
Find the most costly sale	eight	123	55	72
Sum costs where both are males	23	973 *	40	45
Age of youngest who bought for> 50,000	1,521	2.576 *	1,560	1.511
Sort sales by cost	350	1,187	473	453
Extract cars original cost	29	61	31	31
Index cars by brand	57	70	89	415
Group sales by buyers and sellers	2,586	3.748 *	2,862	1.601
Find most bought car	744	1.023 *	CRASH	1,435

Guava is a fairly extensive library, but its core is made up of classes for working with collections, the library itself has grown out of google-collections. These classes implement everything for working with collections, which is missing in the JDK today. If you take a closer look at JDK 8, you always get the feeling that this or that new feature already exists in guava. It is possible that the developers of the eighth java relied precisely on the experience of the guava.

LamdaJ, despite its name, does not provide the ability to write lambda expressions, it is rather a library for working with collections. It gives you the ability to filter, convert, group items of collections, while the code is very compact and readable. It is implemented by means of reflection and glib, and it is obvious that one has to pay for productivity with productivity. About LambdaJ already wrote on Habré .

In JDK 8, lambda expressions will be implemented already at the compiler level and will be converted to bytecode at the compilation stage, therefore, theoretically, the performance of such code should be higher.
')

Performance comparison

In order to practically compare the performance of lambda expressions from JDK 8 with LambdaJ, Guava and the usual iterative approach, LambdaJ performance tests were taken and analogs were written on JDK 8 and Guava.

The initial test code for the iterative variant and LambdaJ was not touched, the test names are saved in English to avoid confusion. The testing methodology is as follows: tests are run in 100 passes, where each test is run 100,000 times, the total time taken to complete each pass is measured and averaged.

Not all LambdaJ tests were launched in JRE 8, they are marked with an asterisk in the table, the results for them were measured in JRE 7. In one test, the lambda expression dropped the virtual machine completely.

The tests were performed on a computer with the following configuration: Core i5 760 2.8 GHz 8 GB Win 7 sp-1 64 bit lambda-8-b45-windows-x64-24_jun_2012 jdk-7u4-windows-x64.

As a result, the best results were given by the iterative code, Guava and JDK lambda. They give quite comparable results. In general, we can say that lambda expressions provide a completely satisfactory replacement for iterations and anonymous classes. Both JDK 8, Guava, and the iterative approach give very similar results, but LamdaJ is almost an order of magnitude behind, the reason most likely lies in the wide use of reflection.

It should be noted that Guava and JDK lambda have one feature when working with collections. They often return not the copied collection, but its live view, which postpones the calculations until the time it accesses the elements of this view. Therefore, in the tests, all the live views were clearly converted into collections. Otherwise, some tests would give a result of almost 0 milliseconds. I also have to say that in real life no one demands to make a choice in favor of any approach, for example, Guava will be perfectly combined with lambda expressions.

Example

For an example of how the source code for each of the approaches looks like, you can look at the FindAgeOfYoungestWhoBoughtForMoreThan50000Test test. In this test, a list of car dealership sales is given, and in this list is the age of the youngest buyer who made the purchase for more than 50,000 any money.

Iterative approach

int age = Integer.MAX_VALUE; for (final Sale sale : db.getSales()) { if (sale.getCost() > 50000.00) { final int buyerAge = sale.getBuyer().getAge(); if (buyerAge < age) { age = buyerAge; } } }

LambdaJ

 final int age = Lambda.min(forEach(select(db.getSales(), having(on(Sale.class).getCost(), greaterThan(50000.00)))).getBuyer(), on(Person.class).getAge());

JDK 8 lambda

 final int age = Collections.min(db.getSales() .filter((Sale sale)->sale.getCost() > 50000.00) .<Integer>map((Sale sale)->sale.getBuyer().getAge()) .into(new ArrayList<Integer>()));

Guava

 final int age = Collections.min(transform(filter(db.getSales(), new Predicate<Sale>() { @Override public boolean apply(final Sale input) { return input.getCost() > 50000.00; } }), new Function<Sale, Integer>() { @Override public Integer apply(final Sale input) { return input.getBuyer().getAge(); } }));

Update

On the advice of TheShade, I made changes to the testing procedure: I added warming up and calculation of confidence intervals. Results changed as follows:

	Iterative	Lambdaj	JDK 8 lambda	Guava
Print all brands	797.3	4,436.6 *	1,073.2	912.1
Select all sales of a Ferrari	471.1	1,359.6	398.5	341.7
Find buys of youngest person	12,102.4	17.436.2	12,267.4	12,144.5
Find the most costly sale	89.7	1,237.2	742.8	676.6
Sum costs where both are males	173.7	8,979.8 *	372.7	394.5
Age of youngest who bought for> 50,000	11,971.2	28,091.9 *	11,672.1	15,975.6
Sort sales by cost	3.261	12,566.1	4,558.8	3,242.5
Extract cars original cost	292.1	628	322.8	213.1
Index cars by brand	548.8	672.1	867.8	4,324.6
Group sales by buyers and sellers	25,986.3	39,339.3 *	28,109.2	15,068.9
Find most bought car	7,378.3	9,317.2 *	CRASH	10,002.1

Source: https://habr.com/ru/post/146718/

All Articles