{"id":510,"date":"2010-10-31T14:31:00","date_gmt":"2010-10-31T12:31:00","guid":{"rendered":""},"modified":"2023-03-23T12:50:06","modified_gmt":"2023-03-23T11:50:06","slug":"google-guava-v07-examples","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2010\/10\/31\/google-guava-v07-examples\/","title":{"rendered":"Google Guava v07 examples"},"content":{"rendered":"
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\u00f3chniak had a talk about Clojure<\/a>, this time a few folks asked for an introduction to Google Guava libraries<\/a>.Since this was a dead simple task, I was happy to deliver.<\/p>\n

WTF is Guava?<\/strong><\/p>\n

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.<\/p>\n

There is an early (v04) presentation<\/a> and there was a different one<\/a> (in Polish) at Javarsowia 2010 by Wiktor Gworek<\/a>.<\/p>\n

At the time of writing this, the latest version is v07, it’s been mavenized and is available at a public maven repo<\/a>.<\/p>\n

Here’s a quick review of a few interesting things. Don’t expect anything fancy though, Guava is very BASIC.<\/p>\n


\n@VisibleForTesting <\/strong><\/p>\n

A simple annotation that tells you why a particular property access restriction has been relaxed.<\/p>\n

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.<\/p>\n

Consider:<\/p>\n

public class User {\r\n    private Long id;\r\n    private String firstName;\r\n    private String lastName;\r\n    String login;<\/pre>\n
Why is login package scoped?<\/p>\n
public class User {\r\n    private Long id;\r\n    private String firstName;\r\n    private String lastName;\r\n    @VisibleForTesting String login;<\/pre>\n
Ah, that’s why.<\/p>\n

\nPreconditions<\/strong><\/p>\n
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:<\/p>\n
Using hand written preconditions:<\/p>\n
public User(Long id, String firstName, String lastName, String login) {\r\n        validateParameters(id, firstName, lastName, login);\r\n        this.id = id;\r\n        this.firstName = firstName;\r\n        this.lastName = lastName;\r\n        this.login = login.toLowerCase();\r\n    }\r\n\r\n    private void validateParameters(Long id, String firstName, String lastName, String login) {\r\n        if(id == null ) {\r\n            throw new IllegalArgumentException(\"id cannot be null\");\r\n        }\r\n\r\n        if(firstName == null || firstName.length() == 0) {\r\n            throw new IllegalArgumentException(\"firstName cannot be empty\");\r\n        }\r\n\r\n        if(lastName == null || lastName.length() == 0) {\r\n            throw new IllegalArgumentException(\"lastName cannot be empty\");\r\n        }\r\n\r\n        if(login == null || login.length() == 0) {\r\n            throw new IllegalArgumentException(\"login cannot be empty\");\r\n        }\r\n    }<\/pre>\n
Using guava preconditions:<\/p>\n
public void fullyImplementedGuavaConstructorWouldBe(Long id, String firstName, String lastName, String login) {\r\n        this.id = checkNotNull(id);\r\n        this.firstName = checkNotNull(firstName);\r\n        this.lastName = checkNotNull(lastName);\r\n        this.login = checkNotNull(login);\r\n\r\n        checkArgument(firstName.length() > 0);\r\n        checkArgument(lastName.length() > 0);\r\n        checkArgument(login.length() > 0);\r\n    }<\/pre>\n
(Thanks Yom for noticing that checkNotNull must go before checkArgument, though it makes it a bit unintuitive)<\/p>\n
Using spring or apache commons preconditions (the use looks exactly the same for both libraries):<\/p>\n
public void springConstructorWouldBe(Long id, String firstName, String lastName, String login) {\r\n        notNull(id); hasText(firstName); hasText(lastName); hasText(login);\r\n        this.id = id;\r\n        this.firstName = firstName;\r\n        this.lastName = lastName;\r\n        this.login = login;\r\n    }<\/pre>\n
CharMatcher<\/strong><\/p>\n
For people who hate regexp or just want a simple and good looking object style pattern matching solution.<\/p>\n
Examples:<\/p>\n
And\/or ease of use<\/p>\n
        String input = \"This invoice has an id of 192\/10\/10\";\r\n        CharMatcher charMatcher = CharMatcher.DIGIT.or(CharMatcher.is('\/'));\r\n        String output = charMatcher.retainFrom(input);<\/pre>\n
output is: 192\/10\/10<\/p>\n
Negation:<\/p>\n
        String input = \"DO NOT scream at me!\";\r\n        CharMatcher charMatcher = CharMatcher.JAVA_LOWER_CASE.or(CharMatcher.WHITESPACE).negate();\r\n        String output = charMatcher.retainFrom(input);<\/pre>\n
output is: DONOT!<\/p>\n
Ranges:<\/p>\n
        String input = \"DO NOT scream at me!\";\r\n        CharMatcher charMatcher = CharMatcher.inRange('m', 's').or(CharMatcher.is('a').or(CharMatcher.WHITESPACE));\r\n        String output = charMatcher.retainFrom(input);<\/pre>\n
output is: sram a m<\/p>\n
Joiner \/ Splitter<\/strong><\/p>\n
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.<\/p>\n
        String[] fantasyGenres = {\"Space Opera\", \"Horror\", \"Magic realism\", \"Religion\"};\r\n        String joined = Joiner.on(\", \").join(fantasyGenres);<\/pre>\n
Output: Space Opera, Horror, Magic realism, Religion<\/p>\n
You can skip nulls:<\/p>\n
        String[] fantasyGenres = {\"Space Opera\", null, \"Horror\", \"Magic realism\", null, \"Religion\"};\r\n        String joined = Joiner.on(\", \").skipNulls().join(fantasyGenres);<\/pre>\n
Output: Space Opera, Horror, Magic realism, Religion<\/p>\n
You can fill nulls:<\/p>\n
        String[] fantasyGenres = {\"Space Opera\", null, \"Horror\", \"Magic realism\", null, \"Religion\"};\r\n        String joined = Joiner.on(\", \").useForNull(\"NULL!!!\").join(fantasyGenres);<\/pre>\n
Output: Space Opera, NULL!!!, Horror, Magic realism, NULL!!!, Religion<\/p>\n
You can join maps<\/p>\n
        Map map = newHashMap();\r\n        map.put(1, \"Space Opera\");\r\n        map.put(2, \"Horror\");\r\n        map.put(3, \"Magic realism\");\r\n        String joined = Joiner.on(\", \").withKeyValueSeparator(\" -> \").join(map);<\/pre>\n
Output: 1 \u2192 Space Opera, 2 \u2192 Horror, 3 \u2192 Magic realism<\/p>\n
Split returns Iterable instead of JDK arrays:<\/p>\n
        String input = \"Some very stupid data with ids of invoces like 121432, 3436534 and 8989898 inside\";\r\n        Iterable splitted = Splitter.on(\" \").split(input);<\/pre>\n
Split does fixed length splitting, although you cannot give a different length for each \u201ccolumn\u201d which makes it’s use a bit limited while parsing some badly exported excels.<\/p>\n
        String input =\r\n                \"A  1  1  1  1\\n\" +\r\n                \"B  1  2  2  2\\n\" +\r\n                \"C  1  2  3  3\\n\" +\r\n                \"D  1  2  5  3\\n\" +\r\n                \"E  3  2  5  4\\n\" +\r\n                \"F  3  3  7  5\\n\" +\r\n                \"G  3  3  7  5\\n\" +\r\n                \"H  3  3  9  7\";\r\n        Iterable splitted = Splitter.fixedLength(3).trimResults().split(input);<\/pre>\n
You can use CharMatcher while splitting<\/p>\n
        String input = \"Some very stupid data with ids of invoces like 123231\/fv\/10\/2010, 123231\/fv\/10\/2010 and 123231\/fv\/10\/2010\";\r\n        Iterable splitted = Splitter.on(CharMatcher.DIGIT.negate())\r\n                                            .trimResults()\r\n                                            .omitEmptyStrings()\r\n                                            .split(input);<\/pre>\n
Predicates \/ Functions<\/strong><\/p>\n
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.<\/p>\n
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):<\/p>\n
Predicates.in(users).apply(shouldNotHaveDigitsInLoginPredicate);<\/pre>\n
And the predicate looks like that<\/p>\n
public class ShouldNotHaveDigitsInLoginPredicate implements Predicate {\r\n    @Override\r\n    public boolean apply(User user) {\r\n        checkNotNull(user);\r\n        return CharMatcher.DIGIT.retainFrom(user.login).length() == 0;\r\n    }    \r\n}<\/pre>\n
Now lets add a function that will transform a user to his full name:<\/p>\n
public class FullNameFunction implements Function {\r\n    @Override\r\n    public String apply(User user) {\r\n        checkNotNull(user);\r\n        return user.getFirstName() + \" \" + user.getLastName();\r\n    }    \r\n}<\/pre>\n
You can invoke it using static method transform:<\/p>\n
List users = newArrayList(new User(1L, \"sylwek\", \"stall\", \"rambo\"),\r\n  new User(2L, \"arnold\", \"schwartz\", \"commando\"));\r\n\r\nList fullNames = transform(users, new FullNameFunction());<\/pre>\n
And now lets combine predicates with functions to print names of users that have logins which do not contain digits:<\/p>\n
List users = newArrayList(new User(1L, \"sylwek\", \"stall\", \"rambo\"), \r\n  new User(2L, \"arnold\", \"schwartz\", \"commando\"), \r\n  new User(3L, \"hans\", \"kloss\", \"jw23\"));\r\n\r\nCollection usersWithoutDigitsInLogin = filter(users, new ShouldNotHaveDigitsInLoginPredicate());\r\nString names = Joiner.on(\"\\n\").join( transform(usersWithoutDigitsInLogin, new FullNameFunction()) );<\/pre>\n
What we do not get: fold (reduce)<\/a> and tuples<\/a>. Oh well, you’d probably turn to Java Functional Library<\/a> anyway, if you wanted functions in Java, right?<\/p>\n
CaseFormat<\/strong><\/p>\n
Ever wanted to turn those ugly PHP Pear<\/a> names into nice java\/cpp style with one liner? No? Well, anyway, you can:<\/p>\n
String pearPhpName = \"Really_Fucked_Up_PHP_PearConvention_That_Looks_UGLY_because_of_no_NAMESPACES\";\r\nString javaAndCPPName = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL , pearPhpName);<\/pre>\n
Output: ReallyFuckedUpPhpPearconventionThatLooksUglyBecauseOfNoNamespaces<\/p>\n
But since Oracle has taken over Sun, you may actually want to turn those into sql style, right?<\/p>\n
        String sqlName = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, javaAndCPPName);<\/pre>\n
Output: really_fucked_up_php_pearconvention_that_looks_ugly_because_of_no_namespaces<\/p>\n
Collections<\/strong><\/p>\n
Guava has a superset of Google collections library 1.0<\/a>, 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:<\/p>\n