The Explorer

[Google Guava] Guava goodness – loading a file from a directory hierarchy

Posted in java on March 25th, 2013 by Wojciech Soczyński – 3 Comments

The case:

we want to have an ability to override some static resources in the application
we can have multiple overrides
there is a hierarchy which decides which file is selected if we have multiple overrides
the hierarchy is fixed from the most important to the less important directories

The code:

class HierarchyAwareResourceLoader { private final List<String> searchPaths; public HierarchyAwareResourceLoader(List<String> searchPaths){ this.searchPaths = searchPaths; } public Optional<File> load(String name){ Optional<File> result = FluentIterable.from(searchPaths). transform(ConcatPath.with(name)). transform(File.createFromPath()). filter(File.ifExists()). first(); return result; } }

The other code :

class ConcatPath implements Function<String,String> { private final String subPath; private ConcatPath(String subPath){ this.subPath = subPath; } @Override public String apply(String basePath){ return FilenameUtils.concat(basePath,subPath); } public static ConcatPath with(String subPath){ return new ConcatPath(subPath); } } public class FileCreator implements Function<String, File> { @Override public File apply(String path){ File result = new File(path); return result; } } public class FileExistanceChecker implements Predicate<File> { @Override public boolean apply(File input){ return input.exists(); } } public class File { public static FileCreator createFromPath(){ return new FileCreator(); } public static FileExistanceChecker ifExists(){ return new FileExistanceChecker(); } }

Joy

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

Posted in java, programowanie on March 16th, 2013 by Wojciech Soczyński – Be the first to comment

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.

Between Java and PHP – Arrays

Posted in java, php, programowanie on December 21st, 2012 by Wojciech Soczyński – Be the first to comment

Most PHP developers, that start learning Java face the same shocking issue – Java does not have arrays ! Well it is not completely true, Java has a notion of arrays, but not it the sense that most PHP developers are familiar to.

In PHP, the array is an universal container. It can be used as a map:

<?php $foo = array( "bar" => 10, "baz" => "zzz" ); $foo54 = ["bar" => 10, "baz" => "zzz"]; //valid from php 5.4 ?>

and as a list:

In PHP arrays are used everywhere, because they are very convenient. There are plenty of awesome functions that operate on arrays, to name just a few:

array_map
reduce
sorting functions
array_filter

The last cool feature of a PHP array is that, it remembers the order in which the elements where added.

In Java, things are slightly different. There are several collection types:

array – not actually a collection in Java sense, it has a fixed length (similar to SplFixedArray)
Map – a typed hash map (similar to PHP’s array, when we use string’s as keys), similar to SPLObjectStorage
List – a typed list – a container which remembers the order in which the items was added, similar to SPLDoublyLinkedList
Set – a typed collection of unique items

Every collection type is iterable (which means that you can use the for-each loop to iterate over it). All collection types derive from the base abstract Collection class.

The types that I have mentioned above are just interfaces, every one of it has different implementations which have some slightly different properties:

Map – implemented by HashMap and LinkedHashMap, the LinkedHashMap retains the insertion order
List – implemented by ArrayList and LinkedList, both implementations differ mainly in the speed of the operations – the ArrayList is faster for reading and the LinkedList is faster for writing
Set – implemented by HashSet, TreeSet and LinkedHashSet – the LinkedHashSet retains the insertion order, the TreeSet is sorted and the HashSet is the fastests

To even further complicate the notion of collections in Java, every collection type has it’s immutable form .

To sum it all up, transitioning from PHP to Java in case of Arrays is not that difficult, you must just resolve which collection type you should use in each case. I will show some examples in the next post of this series, so stay tuned.

The Optional type in Google Guava

Posted in java, programowanie on November 6th, 2012 by Wojciech Soczyński – Be the first to comment

Hi folks ! There was some time ago when I was actively blogging (half of the year or so), so I felt a bit ashamed and decided to write about something interesting. As you probably know I’m working now as a Java developer. Because I’m not a big fan of Java (actually I do hate it) I look from time to time for solutions to over-go Java’s shortcomings.

Gambling with Scala pt.1

Posted in java, programowanie on March 27th, 2012 by Wojciech Soczyński – Be the first to comment

For some time I was eager to write some sample application that will be using Scala and the Akka actors framework. The main problem was to pick up an example, that would make sense to apply both technologies. The idea for the example came to me all of sudden, when I was sitting with my friends after a soccer game. Usually, when you play a game, you are talking about it right after it ends, but this time it was different. My colleagues were talking about poker !

The Explorer

[Google Guava] Guava goodness – loading a file from a directory hierarchy

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

Between Java and PHP – Arrays

The Optional type in Google Guava

Gambling with Scala pt.1

Language

Subscribe

business analysis

flash

javascript

php

general programming

private

software quality

The Explorer

[Google Guava] Guava goodness – loading a file from a directory hierarchy

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

Between Java and PHP – Arrays

The Optional type in Google Guava

Gambling with Scala pt.1

Language

Subscribe

Tagi / Tags

business analysis

flash

javascript

php

general programming

private

software quality