This is a short post about a method I recently discovered in Guava.

The Issue

I had a situation at work where I was working with objects structured something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Outer {
    String outerId;
    List<Inner> innerList;
    .......
}

public class Inner {
    String innerId;
    Date timestamp;
}

public class Merged {
    String outerId;
    String innerId;
    Date timestamp;
}

My task was flatten a list Outer objects (along with the list of Inner objects) into a list of Merged objects. Since I’m working with Java 7, using streams is not an option.

The First Solution

Instead I turn to the FluentIterable class from Guava. My first instinct is to go with the FluentIterable.transform method (which is essentially a map function):

1
2
3
4
5
6

List<Outer> originalList = getListOfObjects();

Function<Outer,List<Merged>> flattenFunction //Details left out for clarity

//returns an Iterable of Lists!
Iterable<List<Merged>> mergedObjects = FluentIterable.from(originalList).tranform(flattenFunction);

But I really want a single collection of Merged objects, not an iterable of lists! The missing ingredient here is a flatMap function. Since I’m not using Scala, Clojure or Java 8, I feel that I’m out of luck.

A Better Solution

I decide to take a closer look at the FluentIterable class and I discover the FluentIterable.transformAndConcat method. The transformAndConcat method applies a function to each element of the fluent iterable and appends the results into a single iterable instance. I have my flatMap function in Guava! Now my solution looks like this:

1
2
3
4
5

List<Outer> originalList = getListOfObjects();

Function<Outer,List<Merged>> flattenFunction //Details left out for clarity

Iterable<Merged> mergedObjects = FluentIterable.from(originalList).transformAndConcat(flattenFunction);

Conclusion

While this is a very short post, it goes to show how useful the Guava library is and how functional programming concepts can make our code more concise.