The native Java switch construct has been often criticized for its limited applicability, since it can operate only on ints, chars and (starting from Java 5) enums. For example Scala has demonstrated how power and flexible its pattern matching construct could be. Getting inspiration from it, the last version of lambdaj introduces a Switcher object that through a smart use of its closures and the matchers provided by hamcrest, greatly enriches the features of the java switch. That allows to implement factory and strategy pattern in a readable and almost declarative way.

For example let's suppose you need a strategy that switchs among three sorting algorithms based on some characteristic of the list to be sorted. In particular let's assume we have an algorithm specialized for Strings:

public List<String> sortStrings(List<String> list) {
    // a sort algorithm suitable for Strings
}

another one that works well with small lists having no more than 100 items:

public List<T> sortSmallList(List<T> list) {
    // a sort algorithm suitable for no more than 100 items
}

and a more general purpose one:

public List<String> sort(List<String> list) {
    // a generic sort algorithm
}

Given these 3 sorting methods it is possible to create a strategy that chooses the most suitable of them in the following declarative way:

Switcher<List<T>> sortStrategy = new Switcher<List<T>>()
    .addCase(having(on(List.class).get(0), instanceOf(String.class))),
        new Closure() {{ of(this).sortStrings(var(List.class)); }})
    .addCase(having(on(List.class).size(), lessThan(100))),
        new Closure() {{ of(this).sortSmallList(var(List.class)); }})
    .setDefault(new Closure() {{ of(this).sort(var(List.class)); }});

In this way it is possible to sort a list using the best available algorithm by invoking the Switcher as it follows:

List<T> sortedList = sortStrategy.exec(list, list);

In this case, the list must be passed twice to the Switcher: once to decide, through the hamcrest Matchers, which sorting method should be used and once to be passed to the closure that will actually do the sort.

The release 2.2 of lambdaj also allows to define blocks that invoke constructors. By using this last feature, it is easy to define a Switcher implementing a factory pattern, that creates different objects based on different conditions once again defined through hamcrest matchers.