My day-to-day work often consists of writing web applications that aggregate data from a number of sources. Corporate constraints frequently dictate that I cannot use languages that make crunching of collections easier so I am forced into an old-fashioned for-loop frenzy. Ugh.
On a recent java project my pairing buddy (Jules – thank you) suggested that we look at lambdaj. From the lamdbaj site: “lambdaj is a library that makes easier to address this issue by allowing to manipulate collections in a pseudo-functional and statically typed way”. The following examples are very contrived but I’m sure you’ve seen something like them:
Old school:
List<Customer> activeCustomers = new ArrayList<Customer>();
for (Customer customer : customers) {
if (customer.isActive()) {
activeCusomers.add(customer);
}
}
List<Account> accounts = new ArrayList<Account>();
for (Customer customer : activeCustomers) {
accounts.addAll(customer.getAccounts());
}
Map<String, List<Account>> groups = new HashMap<String, List<Account>>();
for (Account account : accounts) {
String type = account.getType();
List<Account> group = groups.get(type);
if (group == null) {
group = new ArrayList<Account>();
groups.put(type, group);
}
group.add(account);
}
New hotness:
List<Customer> activeCustomers = select(customers, having(on(Customer.class).isActive(), equalTo(true))); List<Account> accounts = flatten(extract(activeCustomers, on(Customer.class).getAccounts())); Group<Account> groups = group(accounts, by(on(Account.class).getType()));
My verdict: lambdaj certainly lives up to its promises. Obviously the old-school java code will be faster but is it easier to write or more readable? You decide …