Java 8 Lambdas vs Groovy Closures Compactness: Grouping And Summing

Ted VinkeJune 23rd, 2014Last Updated: June 23rd, 2014

0 103 2 minutes read

Java 8 is featuring lambdas, which are similar to a construction Groovy has already for some time: closures.

In Groovy we could already do this:

def list = ['a', 'b', 'c']
print list.collect { it.toUpperCase() }
// [A, B, C]

where { it.toUpperCase() } is the closure.

In Java 8 we can achieve the same functionality now in a concise way.

1	`list.stream().map( s -> s.toUpperCase() )`

Although you could argue that with proper use of the new Stream API, bulk operations and method references, at least the intent of a piece of code is conveyed more clearly now – Java’s verboseness can still cause sore eyes.

Here are some other examples.

Some Groovy animals

class Animal {
    String name
    BigDecimal price
    String farmer
    String toString() { name }
}
 
def animals = []
animals << new Animal(name: "Buttercup", price: 2, farmer: "john")
animals << new Animal(name: "Carmella", price: 5, farmer: "dick")
animals << new Animal(name: "Cinnamon", price: 2, farmer: "dick")

Example 1: Summing the total price of all animals

Groovy

assert 9 == animals.sum { it.price }
// or animals.price.sum()

What Groovy you see here:

sum can be called on a List and optionally passed a closure defining the property of “it” – the animal being iterated over – to sort on.
or sum can be called on a List without any arguments, which is equivalent to invoking the “plus” method on all items in the collection.

Java 8

Optional<BigDecimal> sum =
    animals.
        stream().
        map(Animal::getPrice).
        reduce((l, r) -> l.add(r));
assert BigDecimal.valueOf(9) == sum.get();

What Java you see here:

Through the Stream API’s stream method we can create a pipeline of operations, such as map and reduce
The argument to the map operation is a method reference to the getPrice() method of the currently iterated animal. We could also replace this part with the expression a -> a.getPrice()
reduce is a general reduction operation (also called a fold) in which the BigDecimals of the prices are added up. This is also giving us an Optional with the total sum.
BTW, if we were to use a double for price – which we don’t because I want to give a good example – we could have used an existing DoubleStream with a sum() on it e.g.
1
double sum = animals.stream().mapToDouble(Animal::getPrice).sum();

Example 2: Grouping all animals by farmer

Groovy

def animalsByFarmer = animals.groupBy { it.farmer }
// [john:[Buttercup], dick:[Carmella, Cinnamon]]

Java 8

Map<String, List<Animal>> animalsByFarmer =
    animals
        .stream()
        .collect(
            Collectors.groupingBy(Animal::getFarmer));
// {dick=[Carmella, Cinnamon], john=[Buttercup]}

Example 3: Summing the total price of all animals grouped by farmer

Groovy

def totalPriceByFarmer =
    animals
        .groupBy { it.farmer }
        .collectEntries { k, v -> [k, v.price.sum()] }
// [john:2, dick:7]

What Groovy you see here:

collectEntries iterates through the “groupBy” map transforming each map entry using the k, v -> ... closure returning a map of the transformed entries. v.price is actually a List of prices (per farmer) – such as in example 1 – on which we can call sum().

Java 8

Map<String, BigDecimal> totalPriceByFarmer =
    animals
        .stream()
        .collect(
            Collectors.groupingBy(
                Animal::getFarmer,
                Collectors.reducing(
                    BigDecimal.ZERO,
                    Animal::getPrice,
                    BigDecimal::add)));
// {dick=7, john=2}

This Java code again yields the same results. Since IDE’s, Eclipse at least, don’t format this properly, you’ll have to indent these kinds of constructions for readability a bit yourself.

Reference:

Java 8 Lambdas vs Groovy Closures Compactness: Grouping And Summing from our JCG partner Ted Vinke at the Ted Vinke’s Blog blog.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design