Google Guava v07 examples

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.concurrent, primitives, io and net packages, but you probably already know what to expect.

Happy coding and don’t forget to share!

Reference: Google Guava v07 examples from our JCG partner Jakub Nabrdalik at the Solid Craft blog.