We have something called Weekly Technology Workshops at TouK, that is, every Friday at 16:00 somebody has a presentation for everyone willing to come. We present stuff we learn and work on at home, but we also have a bulletin board with topics that people would like to listen about. Last week Maciej Próchniak had a talk about
Clojure, this time a few folks asked for an introduction to
Google Guava libraries.
Since this was a dead simple task, I was happy to deliver.
WTF is Guava?
It's a set of very simple, basic classes, that you end up writing yourself anyway. Think in terms of Apache commons, just by Google. Just to make your life a little bit easier.
There is an early (v04)
presentation and there was
a different one (in Polish) at Javarsowia 2010 by
Wiktor Gworek.
At the time of writing this, the latest version is v07, it's been mavenized and is available at a
public maven repo.
Here's a quick review of a few interesting things. Don't expect anything fancy though, Guava is very BASIC.
@VisibleForTesting
A simple annotation that tells you why a particular property access restriction has been relaxed.
A common trick to use in testing is to relax access restrictions to default for a particular property, so that you can use it in a unit test, which resides in the same package (though in different catalog). Whether you thing it's good or bad, remember to give a hint about that to the developer.
Consider:
public class User {
private Long id;
private String firstName;
private String lastName;
String login;
Why is login package scoped?
public class User {
private Long id;
private String firstName;
private String lastName;
@VisibleForTesting String login;
Ah, that's why.
Preconditions
Guava has a few preconditions for defensive programming (Design By Contract), but they are not quite as good as what Apache Commons / Spring framework has. One thing interesting is that Guava solution returns the object, so could be inlined. Consider:
Using hand written preconditions:
public User(Long id, String firstName, String lastName, String login) {
validateParameters(id, firstName, lastName, login);
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.login = login.toLowerCase();
}
private void validateParameters(Long id, String firstName, String lastName, String login) {
if(id == null ) {
throw new IllegalArgumentException("id cannot be null");
}
if(firstName == null || firstName.length() == 0) {
throw new IllegalArgumentException("firstName cannot be empty");
}
if(lastName == null || lastName.length() == 0) {
throw new IllegalArgumentException("lastName cannot be empty");
}
if(login == null || login.length() == 0) {
throw new IllegalArgumentException("login cannot be empty");
}
}
Using guava preconditions:
public void fullyImplementedGuavaConstructorWouldBe(Long id, String firstName, String lastName, String login) {
this.id = checkNotNull(id);
this.firstName = checkNotNull(firstName);
this.lastName = checkNotNull(lastName);
this.login = checkNotNull(login);
checkArgument(firstName.length() > 0);
checkArgument(lastName.length() > 0);
checkArgument(login.length() > 0);
}
(Thanks Yom for noticing that checkNotNull must go before checkArgument, though it makes it a bit unintuitive)
Using spring or apache commons preconditions (the use looks exactly the same for both libraries):
public void springConstructorWouldBe(Long id, String firstName, String lastName, String login) {
notNull(id); hasText(firstName); hasText(lastName); hasText(login);
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.login = login;
}
CharMatcher
For people who hate regexp or just want a simple and good looking object style pattern matching solution.
Examples:
And/or ease of use
String input = "This invoice has an id of 192/10/10";
CharMatcher charMatcher = CharMatcher.DIGIT.or(CharMatcher.is('/'));
String output = charMatcher.retainFrom(input);
output is: 192/10/10
Negation:
String input = "DO NOT scream at me!";
CharMatcher charMatcher = CharMatcher.JAVA_LOWER_CASE.or(CharMatcher.WHITESPACE).negate();
String output = charMatcher.retainFrom(input);
output is: DONOT!
Ranges:
String input = "DO NOT scream at me!";
CharMatcher charMatcher = CharMatcher.inRange('m', 's').or(CharMatcher.is('a').or(CharMatcher.WHITESPACE));
String output = charMatcher.retainFrom(input);
output is: sram a m
Joiner / Splitter
As the names suggest, it's string joining/splitting done the right way, although I find the inversion of calls a bit... oh well, it's java.
String[] fantasyGenres = {"Space Opera", "Horror", "Magic realism", "Religion"};
String joined = Joiner.on(", ").join(fantasyGenres);
Output: Space Opera, Horror, Magic realism, Religion
You can skip nulls:
String[] fantasyGenres = {"Space Opera", null, "Horror", "Magic realism", null, "Religion"};
String joined = Joiner.on(", ").skipNulls().join(fantasyGenres);
Output: Space Opera, Horror, Magic realism, Religion
You can fill nulls:
String[] fantasyGenres = {"Space Opera", null, "Horror", "Magic realism", null, "Religion"};
String joined = Joiner.on(", ").useForNull("NULL!!!").join(fantasyGenres);
Output: Space Opera, NULL!!!, Horror, Magic realism, NULL!!!, Religion
You can join maps
Map<Integer, String> map = newHashMap();
map.put(1, "Space Opera");
map.put(2, "Horror");
map.put(3, "Magic realism");
String joined = Joiner.on(", ").withKeyValueSeparator(" -> ").join(map);
Output: 1 → Space Opera, 2 → Horror, 3 → Magic realism
Split returns Iterable instead of JDK arrays:
String input = "Some very stupid data with ids of invoces like 121432, 3436534 and 8989898 inside";
Iterable<String> splitted = Splitter.on(" ").split(input);
Split does fixed length splitting, although you cannot give a different length for each “column” which makes it's use a bit limited while parsing some badly exported excels.
String input =
"A 1 1 1 1\n" +
"B 1 2 2 2\n" +
"C 1 2 3 3\n" +
"D 1 2 5 3\n" +
"E 3 2 5 4\n" +
"F 3 3 7 5\n" +
"G 3 3 7 5\n" +
"H 3 3 9 7";
Iterable<String> splitted = Splitter.fixedLength(3).trimResults().split(input);
You can use CharMatcher while splitting
String input = "Some very stupid data with ids of invoces like 123231/fv/10/2010, 123231/fv/10/2010 and 123231/fv/10/2010";
Iterable<String> splitted = Splitter.on(CharMatcher.DIGIT.negate())
.trimResults()
.omitEmptyStrings()
.split(input);
Predicates / Functions
Predicates alone are not much, it's just an interface with a method that returns true, but if you combine predicates with functions and Collections2 (a guava class that simplifies working on collections), you get a nice tool in your toolbox.
But let's start with basic predicate use. Imagine we want to find whether there are users who have logins with digits inside. The inocation would be (returns boolean):
Predicates.in(users).apply(shouldNotHaveDigitsInLoginPredicate);
And the predicate looks like that
public class ShouldNotHaveDigitsInLoginPredicate implements Predicate<User> {
@Override
public boolean apply(User user) {
checkNotNull(user);
return CharMatcher.DIGIT.retainFrom(user.login).length() == 0;
}
}
Now lets add a function that will transform a user to his full name:
public class FullNameFunction implements Function<User, String> {
@Override
public String apply(User user) {
checkNotNull(user);
return user.getFirstName() + " " + user.getLastName();
}
}
You can invoke it using static method transform:
List<User> users = newArrayList(new User(1L, "sylwek", "stall", "rambo"),
new User(2L, "arnold", "schwartz", "commando"));
List<String> fullNames = transform(users, new FullNameFunction());
And now lets combine predicates with functions to print names of users that have logins which do not contain digits:
List<User> users = newArrayList(new User(1L, "sylwek", "stall", "rambo"),
new User(2L, "arnold", "schwartz", "commando"),
new User(3L, "hans", "kloss", "jw23"));
Collection<User> usersWithoutDigitsInLogin = filter(users, new ShouldNotHaveDigitsInLoginPredicate());
String names = Joiner.on("\n").join( transform(usersWithoutDigitsInLogin, new FullNameFunction()) );
What we do not get:
fold (reduce) and
tuples. Oh well, you'd probably turn to
Java Functional Library anyway, if you wanted functions in Java, right?
CaseFormat
Ever wanted to turn those ugly
PHP Pear names into nice java/cpp style with one liner? No? Well, anyway, you can:
String pearPhpName = "Really_Fucked_Up_PHP_PearConvention_That_Looks_UGLY_because_of_no_NAMESPACES";
String javaAndCPPName = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL , pearPhpName);
Output: ReallyFuckedUpPhpPearconventionThatLooksUglyBecauseOfNoNamespaces
But since Oracle has taken over Sun, you may actually want to turn those into sql style, right?
String sqlName = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, javaAndCPPName);
Output: really_fucked_up_php_pearconvention_that_looks_ugly_because_of_no_namespaces
Collections
Guava has a superset of
Google collections library 1.0, and this indeed is a very good reason to include this dependency in your poms. I won't even try to describe all the features, but just to point out a few nice things:
- you have an Immutable version of pretty much everything
- you get a few nice static and statically typed methods on common types like Lists, Sets, Maps, ObjectArrays, which include:
- easy way of creating based on return type: e.g. newArrayList
- transform (way to apply functions that returns Immutable version)
- partition (paging)
- reverse
And now for a few more interesting collections.
Mutlimaps
Mutlimap is basically a map that can have many values for a single key. Ever had to create a Map<T1, Set<T2>> in your code? You don't have to anymore.
Multimap<Integer, String> multimap = HashMultimap.create();
multimap.put(1, "a");
multimap.put(2, "b");
multimap.put(3, "c");
multimap.put(1, "a2");
There are of course immutable implementations as well: ImmutableListMultimap, ImmutableSetMultomap, etc.
You can construct immutables either in line (up to 5 elements) or using a builder:
Multimap<Integer, String> multimap = ImmutableSetMultimap.of(1, "a", 2, "b", 3, "c", 1, "a2");
Multimap<Integer, String> multimap = new ImmutableSetMultimap.Builder<Integer, String>()
.put(1, "a")
.put(2, "b")
.put(3, "c")
.put(1, "a2")
.build();
BiMap
BiMap is a map that have only unique values. Consider this:
@Test(expected = IllegalArgumentException.class)
public void biMapShouldOnlyHaveUniqueValues() {
BiMap<Integer, String> biMap = HashBiMap.create();
biMap.put(1, "a");
biMap.put(2, "b");
biMap.put(3, "a"); //argh! an exception
}
That allows you to inverse the map, so the values become key and the other way around:
BiMap<Integer, String> biMap = HashBiMap.create();
biMap.put(1, "a");
biMap.put(2, "b");
biMap.put(3, "c");
BiMap<String, Integer> invertedMap = biMap.inverse();
Not sure what I'd actually want to use it for.
Constraints
This allows you to add constraint checking on a collection, so that only values which pass the constraint may be added.
Imagine we want a collections of users with first letter 'r' in their logins.
Constraint<User> loginMustStartWithR = new Constraint<User>() {
@Override
public User checkElement(User user) {
checkNotNull(user);
if(!user.login.startsWith("r")) {
throw new IllegalArgumentException("GTFO, you are not Rrrrrrrrr");
}
return user;
}
};
And now for a test:
@Test(expected = IllegalArgumentException.class)
public void shouldConstraintCollection() {
//given
Collection<User> users = newArrayList(new User(1L, "john", "rambo", "rambo"));
Collection<User> usersThatStartWithR = constrainedCollection(users, loginMustStartWithR);
//when
usersThatStartWithR.add(new User(2L, "arnold", "schwarz", "commando"));
}
You also get notNull constraint out of the box:
//notice it's not an IllegalArgumentException :(
@Test(expected = NullPointerException.class)
public void notNullConstraintShouldWork() {
//given
Collection<Integer> users = newArrayList(1);
Collection<Integer> notNullCollection = constrainedCollection(users, notNull());
//when
notNullCollection.add(null);
}
Thing to remember: constraints are not checking the data already present in a collection.
Tables
Just as expected, a table is a collection with columns, rows and values. No more Map<T1, Map<T2, T3>> I guess. The usage is simple and you can transpose:
Table<Integer, String, String> table = HashBasedTable.create();
table.put(1, "a", "1a");
table.put(1, "b", "1b");
table.put(2, "a", "2a");
table.put(2, "b", "2b");
Table transponedTable = Tables.transpose(table);
That's all, folks. I didn't present util.concurent, primitives, io and net packages, but you probably already know what to expect.
