The Explorer

[Google Guava] – One class to rule’em all – FluentIterable

Google Guava has a lot of interesting utility classes, just to name a few: Optional, Joiner, Splitter, EventBus, Collections2 etc. But the essence of the whole library is condensed in just one single class – FluentIterable.

The FluentIterable class let’s you combine a set of operations on a collection in a single pipeline, plus it has some nifty methods too :).

To start a pipeline, you should use the simple FluentIterable.from(collection) method:

public class FluentIterableExample { public static void main(String... args){ List<String> input = newArayList(); FluentIterable<String> iterable = FluentIterable.from(input); //the rest of processing } }

Then you can perform typical collection operations. For the purpose of the example, let assume that we want to square all even numbers from 1 to 100 and select from the result the first number that is greater than 17 and smaller than 50.

public class FluentIterableExample { public static void main(String... args){ List<Integer> input = generateInput(); EvenFilter evenFilter = new EvenFilter(); PowerFunction powerFunction = new PowerFunction(2); RangeFilter rangeFilter = new RangeFilter(17, 50); Optional<Double> result = FluentIterable.from(input). filter(evenFilter). transform(powerFunction). firstMatch(rangeFilter); return result.or(Double.valueOf(0)); } private static List<Integer> generateInput(){ List<Integer> result = newLinkedList(); for(int i=1; i<101; i++){ result.add(i); } return result; } } class EvenFilter implements Predicate<Integer> { @Override public boolean apply(Integer integer) { return integer % 2 == 0; } } class PowerFunction implements Function<Integer, Double> { private final double root; public PowerFunction(double root) { this.root = root; } @Override public Double apply(Integer input) { return Math.pow(input, root); } } class RangeFilter implements Predicate<Double> { private final Range range; public RangeFilter(int start, int end) { this.range = Range.closed(Double.valueOf(start), Double.valueOf(end)); } @Override public boolean apply(Double input) { return range.contains(input); } }

Note that for a range comparison I have used the Guava Range class which is a cool utility for dealing with ranges. One can also replace the “generateInput” method with a combination of a ContiguousSet and Range invocations:

public class GenerateTest { @Test public void testGenerate() { //given Set<Integer> expected = new LinkedHashSet<Integer>(); for (int i = 1; i < 101; i++) { expected.add(i); } //when ContiguousSet<Integer> input = ContiguousSet.create(Range.closed(1, 100), DiscreteDomain.integers()); //then assertTrue(Sets.difference(input, expected).isEmpty()); } }

The last but not the least interesting method in the FluentIterable is the transformAndConcat method. It allows to perform a transformation of a collection of some objects and merge the outputs, assuming that the result of a single item transformation was also a collection. This is very handy for situations like making a flat structure from some kind of Tree or a nested List. A common example is a list of files in a tree structure of the file system.

public class TransformAndConcatTest{ @Test public void testTransformAndConcat() throws Exception { //given List<List<Integer>> input = newLinkedList(); for (int i = 0; i < 10; i++) { List<Integer> subList = newLinkedList(); for (int j = 0; j < 10; j++) { subList.add(j); } input.add(subList); } //when ImmutableList<Integer> result = FluentIterable.from(input). transformAndConcat(Functions.<List<Integer>>identity()). toList(); //then assertEquals(100, result.size()); } }

Note in the above example, that I have used an “identity function”. The identity function is a function that simply returns its input.

We are near the end, so for the close up I would like to tell a few words about performance. I have done some tests using the Google Caliper benchmarking library. The case was about squaring every item of a collection which was an even number. I have made two implementations:

…a vanilla Java one:

public class Sample { public List<Double> allEvenNumberToSecondPower(List<Integer> input) { List<Double> result = new LinkedList<Double>(); for (Integer item : input) { if (item % 2 == 0) { result.add(Math.pow(item, 2)); } } return result; } }

… and a Guava based one:

public class Sample { public List<Double> allEvenNumberToSecondPower(List<Integer> input) { EvenFilter evenFilter = new EvenFilter(); PowerFunction powerFunction = new PowerFunction(2); ImmutableList<Double> result = FluentIterable.from(input). filter(evenFilter). transform(powerFunction). toList(); return newArrayList(result); } }

The test:

public class PerfTest extends SimpleBenchmark { private List<Integer> input; public void setUp() { List<Integer> input = new LinkedList<Integer>(); for (int i = 0; i < 10000; i++) { input.add(i); } this.input = new ArrayList<Integer>(input); } public void timeMyTestGuava(int reps) { guavaTest.guava.Sample sample = new guavaTest.guava.Sample(); for (int i = 0; i < reps; i++) { sample.allEvenNumberToSecondPower(input); } } public void timeMyTtestStandard(int reps) { guavaTest.standard.Sample sample = new guavaTest.standard.Sample(); for (int i = 0; i < reps; i++) { sample.allEvenNumberToSecondPower(input); } } }

The test was run 10 times (10 reps) for 20 trials. On the average the Guava solution took about 1,5x time of the Java one.

All in all I think that the performance penalty is not very big and it is beneficial to use the FluentIterable class for the sake of coding pleasure, readability and testability.

Tags: google caliper, google guava, java

This entry was posted on Saturday, March 16th, 2013 at %I:%M %p and is filed under java, programowanie. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

[Google Guava] – One class to rule’em all – FluentIterable

Leave a Reply

Language

Subscribe

business analysis

flash

javascript

php

general programming

private

software quality

The Explorer

[Google Guava] – One class to rule’em all – FluentIterable

Leave a Reply

Language

Subscribe

Tagi / Tags

business analysis

flash

javascript

php

general programming

private

software quality