There is a lot of functional hype these days so I would give a short overview on what is out there at least when it comes to collections in Java. Personally I like standard collections API but i some cases can be awkward and add additional verboseness. This should not be a problem in latter version of Java 8+. There we would probably worry about not creating callback hell but hey there is no silver bullet for most stuff why should there be one for programming?

The Guava Way

Guava project is one of Google's core libraries where there are plenty of different core language aspects and problems covered. There are utilities and extensions for everyday usage like : collections, primitives, caching, common annotations, string processing, I/O, Math, Reflections and many others. We will only take a look at the Collections goodies so lets see some of them :

// list
    ImmutableList<String> of =
        ImmutableList.of("a", "b", "c", "d");
    // Same one for map
    ImmutableMap<String, String> map =
         ImmutableMap.of("key1", "value1", "key2", "value2");
    //list of ints
    List<Integer> theList = Ints.asList(1, 2, 3, 4, 522, 5, 6);

The Guava Collections are compatible with the JDK collections since they mostly extend or implement the standard classes. There are several cool utilities that are part of the API and have similar names with the ones from java.util.Collections. Basically any programmer who knows the JDK collections should be able to transfer to Guava easily. The ones for List is called Lists, one for Set is Sets, for Map is Maps and so on for the rest. For example:

//create new List
List<someLongName> list = Lists.newArrayList();
//create new  LinkedHashMap
Map<someKeyType, SomeValueType> map = Maps.newLinkedHashMap();

//initalize Array List on the spot
List<String> someList = Lists.newArrayList("one", "two", "three");

//set inital size for readability as well as performance
List<Type> exactly100 = Lists.newArrayListWithCapacity(100);
List<Type> approx100 = Lists.newArrayListWithExpectedSize(100);

Methods corresponding to a particular interface are grouped in a very intuitive manner. There are also some extremely good ways of building cache with various of features :

Cache<Integer, Customer> cache = CacheBuilder.newBuilder()
        .weakKeys()
        .maximumSize(10000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(new CacheLoader<Integer, Customer>() {

          @Override
          public Customer load(Integer key) throws Exception {

            return retreveCustomerForKey(key);
          }
        });

Since Guava is available in most of the maven repositories its very easy to add it to your build

lambdaj

The idea behind the project is to manipulate collections in a functional and statically typed way. This is achieved in a way the avoids repetitions of simple tasks we usually do with collections. Repetition makes programmers to go with copy/pasting and creates makes them create bugs by doing so. Accessing collections without explicit looping provides way of filtering, sorting, extraction, grouping, transforming, invoking a method on each item or sum up the elements or fields of those element in a collections. Additionally to all these features lambdaj is also a DSL in a way since it adds very cool "sugar" features to the syntax making it more readable in pseudo-english. This is done with static methods so in order to use them we include them directly:

import static ch.lambdaj.Lambda.*;

sAs it comes to checking and matching lambdaj relies deeply on Hamcrestmatchers. So for example to create a check for an odd integers and then filter a list with that check:

Matcher<Integer> odd = new Predicate<Integer>() {
        public boolean apply(Integer item) {
                return item % 2 == 1;
        }
};
List<Integer> oddNumbers = filter(odd, asList(1, 2, 3, 4, 5));

 and as expected the list will return the list [1,3,5]. Lambdaj take a step further with it's DSL, for example :

List<Beneficiary> beneficiaries = with(transactions)
    .retain(having(on(Transaction.class)
              .getQunatity(), lessThan(100)))
    .extract(on(Transaction.class).getBeneficiary())
    .sort(on(Beneficiary.class).getName());

Performance costs

Although the best way to make your application fast is to have the cleanest code as possible there comes a time when you must optimize.In order to do that there is some info provided by the creators on the memory usage and time. Lambdaj has a performance wiki page with code examples. There are also some test done by other programmers where they compare lambdaj with JDK8 for example. There are also some measurements on memory usage of Guava. As for performance of Guava most of it's functionality is standard JDK classes builders and utilities so the overhead is minimal. At the end of the day it's up to you to decide how much effect each of these libraries will have on your project and if that is positive. I'm for the idea that almost every project must have Guava on it's classpath.

Related links summary

• Guavahttp://code.google.com/p/guava-libraries/
• lambdaj http://code.google.com/p/lambdaj/
• Hamcrest http://hamcrest.org/
• Guava Links http://www.tfnico.com/presentations/google-guava
• Guava examples https://github.com/mitemitreski/guava-examples
• Guava presentation http://blog.mitemitreski.com/2012/07/google-guava-for-cleaner-code.html