Google guava overview

Google Guava Libraries

2013.3.26

Steve Min

Contents
• Introduction
• com.google.common.base
• com.google.common.primitives
• com.google.common.collect
• com.google.common.util.concurrent
• com.google.common.hash
• com.google.common.cache
• Others
• Reference

What’s Guava?
Why Guava?
Guava vs. Apache Commons
Guava Design Principles
Guava Release
Guava Package

INTRODUCTION

What’s Guava?
• Open source version of Google's core Java libraries

• […] Carefully designed, tested, optimized and used in
production at Google

• These utilities relate to: collections, concurrency, primitives,
reflection, comparison, I/O, hashing, networking, strings,
math, in-memory caching, in-memory publish/subscribe...
and various basic data types.

• The “JDK-plus”! (JDK 6+)
• Apache License 2.0

https://code.google.com/p/guava-libraries/wiki/PhilosophyExplained

Why Guava?
• Guava’s goal is for developer to write less code.

• And for the code you do write to be simpler,
cleaner, and more readable.

• Battle tested in production at Google
– Staggering numbers of unit tests: 286,000 as of July
2012 (generated)

• Under active development and has a strong,
vocal, and involved user base

https://code.google.com/p/guava-libraries/wiki/PhilosophyExplained

Guava vs. Apache Commons
• Guava is more “mordern”
– Guava greatly benefits from the Java 5 features: generics, varargs, enums, and
autoboxing
• Guava is very well designed / documented
– factory methods (such as ImmutableList.copyOf())
– builder pattern (ImmutableList.builder(), Joiner, CharMatcher, Splitter ...)
– immutability (immutable collections, CharMatcher, Joiner, Splitter,...)
– implementation hiding (Predicates.xXx, ...)
– favoring composition over inheritance(the ForwardXXX collections)
– null-checks
– enum-singleton pattern
– serialization proxies
– well thought-out naming conventions
• Guava is consistent
• Guava is in active development

tinyurl.com/guava-vs-apache

Guava Design Principles
• There should always be some use case for which the API is clearly
the best solution possible.

• The semantics of methods and classes should be obvious and
intuitive from their signatures, as opposed to "smart."

• Encourage good code habits in Guava users, and exemplify good
code habits ourselves in Guava source.

• Don't try to address every use case individually

• Emphasize maintainability, and leave room for future refactorings.

Guava Release
• Every 3 months, with significant
new functionality and fixes.

• Posted 14.0 last month. (in maven
central: com.google.guava:guava:14.0)

• Guava's classes and methods are
a mixture of API-frozen and
non-API-frozen (marked with
@Beta).

• So all releases are either major
or patch releases; never minor.

https://code.google.com/p/guava-libraries/wiki/ReleaseHistory

Preconditions
Optional
Objects
Strings(Charsets, CaseFormat, CharMatcher, Joiner, Splitter)
StopWatch
Throwables
Functional Programming
COM.GOOGLE.COMMON.BASE

Preconditions (1/3)
• Useful for validation
• Recommended to be used as static imports

Each method has three variants:
• No extra arguments
• An extra object. Exception is obj.toString()
• An extra String & Objects. String.format like
but only allows %s (GWT compat)

Preconditions (2/3) - Examples
import static com.google.common.base.Preconditions.*;

// Before
public Period(Date start, Date end) {
if (null == start || null == end) {
throw new NullPointerException(“Dates cannot be null”);
}
if (start.after(end)) {
throw new IllegalArgumentException(“Start cannot be after end”);
}

this.start = start;
this.end = end;
}

// After
public Period (Date start, Date end) {
this.start = checkNotNull(start, “Start cannot be null”);
this.end = checkNotNull(start, “End cannot be null”);
checkArguments(start.after(end), “Start cannot be after end”);
}

http://www.slideshare.net/alexkorotkikh/google-guava-12991826

Preconditions (3/3)
• checkArgument(boolean)
– Throws IllegalArgumentException if false
– Used to validate method arguments
• checkNotNull(T)
– Throws NullPointerException if null
– Returns the value. Can be used inline
• checkState(boolean)
– Throws IllegalStateException if false
– Used to check object state
• checkElementIndex(index,size)
– Throws IndexOutOfBoundsException
– Interval [0, size) (exclusive)
• checkPositionIndex(index,size)
– Throws IndexOutOfBoundsException
– Interval [0, size] (inclusive)

Optional<T>
An immutable wrapper that is either present(contains a non-null
reference ) or absent(contains nothing) but it never "contains null“.

Optional
Similar to Scala’s Option type
Absent Present
Possible uses:
• return type (vs. null): "a T that must be present“ vs. "a T that might be
absent"
• distinguish between
– "unknown" (for example, not present in a map)
– "known to have no value" (present in the map, with value Optional.absent())
• wrap nullable references for storage in a collection that does not support
null
See the documentation on com.google.common.base.Optional.

http://www.slideshare.net/savu.andrei/guava-overview-part-1-bucharest-jug-1

Optional<T>
• Creating an Optional<T>
• Optional.of(notNull);
• Optional.absent();
• Optional.fromNullable(maybeNull);

• Unwrapping an Optional<T>
• mediaType.charset().get(); // throws IllegalStateException if absent
• mediaType.charset().or(Charsets.UTF_8);
• mediaType.charset().or(costlySupplier);
• mediaType.charset().orNull();

• Other Useful methods
mediaType.charset().asSet(); // 0 or 1
mediaType.charset().transform(stringFunc);

Objects
Useful methods provided by Objects
• Objects.firstNonNull(a, b): return the first non-null object or throw NPE
• Objects.equal(a, b): determines whether two possibly-null objects are
equal
• Objects.hashCode(objects...): generates a hash code for multiple values
• Objects.toStringHelper(): Makes implementing Object.toString() cleaner

The Objects class in JDK 7 or higher provides the equivalent Objects.equals
and Objects.hash(Object...) methods.

See the documentation on com.google.common.base.Objects and Guava's
utilities for implementing common object methods, explained

Objects
Objects.toStringHelper()
// Returns "ClassName{x=1}"
Objects.toStringHelper(this)
.add("x", 1)
.add(“y", null)
.omitNullValues()
.toString();
// Returns "MyObject{x=1, y=null}"
Objects.toStringHelper("MyObject")
.add("x", 1)
.add(“y", null)
.toString();

Strings
Charsets
There are six standard charsets guaranteed to be implemented in
every JVM.
But still there's lots of code like:

try {
bytes = string.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e); // how can this possibly happen?
}

Do this instead:
bytes = string.getBytes(Charsets.UTF_8);

See the documentation on com.google.common.base.Charsets.

http://www.slideshare.net/tomaszdziurko/google-guava-almost-everything-you-need-to-know

Strings
CaseFormat
A handy little class for converting between ASCII case conventions

Supported formats include:
• LOWER_CAMEL: lowerCamel
• LOWER_HYPHEN: lower-hyphen
• LOWER_UNDERSCORE: lower_underscore
• UPPER_CAMEL: UpperCamel
• UPPER_UNDERSCORE: UPPER_UNDERSCORE

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "CONSTANT_NAME"));
// -> "constantName"

See the documentation on com.google.common.base.CaseFormat.

Strings
CharMatcher
• What's a matching character?
– WHITESPACE, ASCII, ANY (many pre-defined sets)
– .is('x'), .isNot('_'), .oneOf("aeiou"), .inRange('a', 'z')
– Or subclass CharMatcher, implement matches(char)

• What to do with those matching characters?
– matchesAllOf, matchesAnyOf, matchesNoneOf
– indexIn, lastIndexIn, countIn
– removeFrom, retainFrom
– trimFrom, trimLeadingFrom, trimTrailingFrom
– collapseFrom, trimAndCollapseFrom, replaceFrom

• Example (scrub a user ID):
CharMatcher.DIGIT.or(CharMatcher.is('-')).retainFrom(userInput);

Strings
CharMatcher
• Scrubbing a user ID from user input:
private static final CharMatcher ID_MATCHER = CharMatcher.DIGIT.or(CharMatcher.is('-'));
// ...

ID_MATCHER.retainFrom("54-74-90not_a_digit-2014");
// -> "54-74-90-2014"

• Replace all digits with asterisks:
CharMatcher.JAVA_DIGIT.replaceFrom("54-74-90not_a_digit-2014", "*");
// -> "**-**-**not_a_digit-****"

See the documentation on com.google.common.base.CharMatcher.

Strings
CharMatcher - Predefined
CharMatcher.JAVA_ISO_CONTROL.removeFrom(string);
// remove control characters

CharMatcher.DIGIT.retainFrom(string);
// keep only the digits

CharMatcher.ASCII.retainFrom(string);
// keep only ASCII (code is less than 128) characters

CharMatcher.JAVA_DIGIT.replaceFrom(string, "*");
// star out all digits

CharMatcher.JAVA_DIGIT.or(CharMatcher.JAVA_LOWER_CASE).retainFrom
(string);
// keep only digits or lowercase

Strings
CharMatcher – Factory methods
CharMatcher.anyOf("2468").replaceFrom("123456789", "*")
//star out all even numbers. Output - 1*3*5*7*9

CharMatcher.noneOf("2468").replaceFrom("123456789", "*")
// star out all non-even numbers. Output - *2*4*6*8*

CharMatcher.inRange('a', 'z').or(inRange('A', 'Z'))
CharMatcher.is('x‘)
// matches only the character ‘x’

CharMatcher.isNot('_')
// matches any character except the ‘_’.

Strings
Joiner
Joiner concatenates strings using a delimiter
• throws a NPE on null objects, unless:
– .skipNulls()
– .useForNull(String)
private static final Joiner JOINER = Joiner.on(", ").skipNulls();
JOINER.join(null, "Kurt", "Kevin", null, "Chris");
// -> "Kurt, Kevin, Chris"

• also handle maps
static final MapJoiner MAP_JOINER = Joiner.on("; ")
.useForNull("NODATA")
.withKeyValueSeparator(":");
// Map { "foo": "bar", "quux": null } -> "foo: bar; quux: NODATA"

See the documentation on com.google.common.base.Joiner and
Guava's string utilities, explained.

Strings
String Splitting quiz
• Question: What does this return?
" foo, ,bar, quux,".split(",");

• Answer:
① [" foo", " ", "bar", " quux"]
② ["foo", "bar", "quux"]
③ ["foo", "", "bar", "quux"]
④ [" foo", " ", "bar", " quux", ""]
• We probably want ["foo", "bar", "quux"]. How do we
get it?
Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.split(" foo, ,bar, quux,");
// -> ["foo", "bar", "quux"]

Strings
Splitter
Splitter divides strings into substrings with a delimiter
• A better, more intuitive String.split()
– doesn't silently discard trailing separators
– handles empty pieces predictably
• By default, assumes nothing about whitespace
– .trimResults()
– .omitEmptyStrings()
private static final Splitter SPLITTER = Splitter.on(',').trimResults();
SPLITTER.split("Kurt, Kevin, Chris");
// yields: ["Kurt", "Kevin", "Chris"]

See the documentation on com.google.common.base.Splitter and
Guava's string utilities, explained.

StopWatch
Prefer Stopwatch over System.nanoTime()
 (and definitely over currentTimeMillis()!)
 exposes relative timings, not absolute time
 alternate time sources can be substituted using
Ticker (read() returns nanoseconds)
 toString() gives human readable format
Stopwatch stopwatch = new Stopwatch().start();
stopwatch.start();
doSomeOtherOperation();
long nanos = stopwatch.elapsedTime(TimeUnit.NANOSECONDS);

See the documentation on com.google.common.base.Stopwatch.

Throwables(1/3)
Guava's Throwables utility can frequently
simplify dealing with exceptions.

Quick examples:
try {
someMethodThatCouldThrowAnything();
} catch (IKnowWhatToDoWithThisException e) {
handle(e);
} catch (Throwable t) {
Throwables.propagateIfInstanceOf(t, IOException.class);
Throwables.propagateIfInstanceOf(t, SQLException.class);
throw Throwables.propagate(t);
}

Throwables(2/3) - Propagation
“Guava provides several utilities to simplify propagating exceptions”

• propagate(Throwable)
Propagates the throwable as-is if it is a RuntimeException or an Error, or wraps it
in a RuntimeException and throws it otherwise.
• propagateIfInstanceOf(Throwable,Class<X extends Exception>)
Propagates the throwable as-is, if and only if it is an instance of X
• propagateIfPossible(Throwable)
Throws throwable as-is only if it is a RuntimeException or an Error.
• propagateIfPossible(Throwable, Class<X extends Throwable>)
Throws throwable as-is only if it is a RuntimeException or an Error, or an X.

Throwables(3/3) – Casual Chain
“Guava makes it somewhat simpler to study the causal
chain of an exception, providing three useful methods
whose signatures are self-explanatory”

• getRootCause(Throwable)
• getCausalChain(Throwable)
• getStackTraceAsString(Throwable)

Function
Function<F, T>
• one way transformation of F into T
• T apply(F input)
• most common use: transforming collections (view)

See the documentation on com.google.common.base.Function and
Functional idioms in Guava, explained.

The com.google.common.base.Functions class provides common
functions and related utilites.


Functions
Static utility methods pertaining to Function
instances.

• forMap(Map<A,B>)
• compose(Function<B,C>, Function<A,B>)
• constant(T)
• identiy()
• toStringFunction()

Predicate
Predicate<F>
• determines true or false for a given F
• boolean apply(F input)
• most common use: filtering collections (view)

See the documentation on com.google.common.base.Predicate and
Functional idioms in Guava, explained.

The com.google.common.base.Predicates class provides common
predicates and related utilites.


Predicates
There are considerably more construction and
manipulation methods available in Predicates
• instanceOf(Class)
• assignableFrom(Class)
• contains(Pattern)
• in(Collection)
• isNull()
• alwaysFalse()
• alwaysTrue()
• equalTo(Object)
• compose(Predicate, Function)
• and(Predicate…)
• or(Predicate…)
• not(Predicate…)

Functional Examples

Predicate activeClients = new Predicate() {
public boolean apply(Client client) {
return client.activeInLastMonth();
}
};

// Returns an immutable list of the names of
// the first 10 active clients in the database.
FluentIterable.from(database.getClientList())
.filter(activeClients) // Predicate
.transform(Functions.toStringFunction()) // Function
.limit(10) .toImmutableList();

Utility Classes
Other useful classes in com.google.common.base are:
• Ascii: Static methods and constants pertaining to ASCII characters
• Strings: nullToEmpty, isNullOrEmpty, common{Prefix, Suffix}
• Enums: getIfPresent, valueOfFunction
• Throwables: getStackTraceAsString, getCausalChain, propagateIfIns
tanceOf
• Suppliers: memoizeWithExpiration, ofInstance
• Equivalence: A strategy for determining whether two instances are
considered equivalent

Primitives
A package that helps you work with Java's primitive types.

If you need help doing a primitive task:
① Check the wrapper class (e. g. java.lang.Integer)
② Check java.util.Arrays
③ Check com.google.common.primitives
④ It might not exist! (Write it yourself)

Primitives
• com.google.common.primitives contains utility classes for all
primitives, like Booleans, Bytes, Chars, Doubles, Floats, Ints, Longs,
and Shorts.

• Each has the exact same structure (but has only the subset of
operations that make sense for its type).

• Depending on the primitive type, useful methods like: {checked,
saturated}Cast, contains, indexOf, min, max, join, fromByteArray

• There are also alternate versions of some primitive types
like UnsignedLong orUnsignedInteger with corresponding utility
classes.

• Also see Guava's primitives utilities, explained.

Primitives - Utilities
• Guava provides a number of these general-purpose
utilities
Primitive Type Guava Utilities
byte Bytes, SignedBytes, UnsignedBytes
short Shorts
int Ints, UnsignedInteger, UnsignedInts
long Longs, UnsignedLong, UnsignedLongs
float Floats
double Doubles
char Chars
boolean Booleans

Primitives - Table
Method Longs Ints Shorts Chars Doubles Bytes S.Bytes U.Bytes Booleans

hashCode ○ ○ ○ ○ ○ ○ ○

compare ○ ○ ○ ○ ○ ○ ○ ○

checkedCast ○ ○ ○ ○ ○

saturatedCast ○ ○ ○ ○ ○

contains ○ ○ ○ ○ ○ ○

indexOf ○ ○ ○ ○ ○ ○ ○

lastIndexOf ○ ○ ○ ○ ○ ○ ○

min ○ ○ ○ ○ ○ ○ ○

max ○ ○ ○ ○ ○ ○ ○

concat ○ ○ ○ ○ ○ ○ ○

join ○ ○ ○ ○ ○ ○ ○ ○

toArray ○ ○ ○ ○ ○ ○ ○

asList ○ ○ ○ ○ ○ ○ ○

lexComparator ○ ○ ○ ○ ○ ○ ○ ○

toByteArray ○ ○ ○ ○

fromByteArray ○ ○ ○ ○

Immutable collections
New collection types
Utility Classes
COM.GOOGLE.COMMON.COLLECT
GUAVA'S EXTENSIONS TO THE JDK COLLECTIONS
ECOSYSTEM. THESE ARE SOME OF THE MOST MATURE AND
POPULAR PARTS OF GUAVA.

Guava Collections
What's inside of com.google.common.collect?
• Immutable Collections
• New collection types: Multimap, Multiset, BiMap, Table…
• Forwarding collections, Constrained collections
• Comparator-related utilities like ComparisonChain
• Stuff similar to Apache Commons Collections (but with
consequent support for Generics)
• Some functional programming support (filter, transform, etc.)

Guava Collections
JDK or
Interface Guava Utility Class Guava Immutable Version
Guava
Collections2
Collection JDK ImmutableCollection
(avoiding java.util.Collections)
List JDK Lists ImmutableList
Set JDK Sets ImmutableSet
SortedSet/NavigableSet JDK Sets ImmutableSortedSet
Map JDK Maps ImmutableMap
SortedMap JDK Maps ImmutableSortedMap
Queue JDK Queues -
Multiset Guava Multisets ImmutableMultiset
SortedMultiset Guava Multisets ImmutableSortedMultiset
Multimap Guava Multimaps ImmutableMultimap
ListMultimap Guava Multimaps ImmutableListMultimap
SetMultimap Guava Multimaps ImmutableSetMultimap
BiMap Guava Maps ImmutableBiMap
ClassToInstanceMap Guava Maps ImmutableClassToInstanceMap
Table Guava Tables ImmutableTable

https://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained

Why immutable?
How to create immutable

IMMUTABLE COLLECTIONS

Why immutable?
• Safe for use by untrusted libraries
• Thread-safe
• More efficient, time & space (analysis)
• Can be used as a constant

• Immutable vs. unmodifiable
– Very easy to use
– Slightly faster
– Use less memory
• Sometimes far less (ImmutableSet, factor of 2~3x)

How to create immutable
Immutable** can be created in several ways:
• copyOf(T): e.g. ImmutableSet.copyOf(set)
• of(elements): e.g. ImmutableMap.of(“a”,”b”)
• using a Builder:
public static final ImmutableSet<Color> GOOGLE_COLORS =
ImmutableSet.<Color>builder()
.addAll(WEBSAFE_COLORS)
.add(new Color(0, 191, 255))
.build();

All collections support asList(const. time view)

Multiset
Multimap
Bimap
Table
RangeSet
RangeMap

NEW COLLECTION TYPES

Multiset
• a set of counters; also called a "bag"
– counts the # of times each unique value was added
– meant to replace Map<K, Integer>
– implementations: HashMultiset,LinkedHashMultiset,TreeMultiset
// convention: construct using create() method
Multiset<String> mset = HashMultiset.create();

"the"=7
"if"=2 "of"=1
mset.count("to") "to"=3
"down"=1 "from"=4 3

set.count("boo") "by"=2 "she"=2 0
set.contains("boo") "in"=5 "you"=4 false
"him"=2

multiset
See also com.google.common.collect.Multiset

Multiset methods
class.create() creates a new empty multiset,
class.create(collection) or one based on the elements of a collection
add(value) adds 1 occurrence of value to collection; or
add(value, count) adds the given # of occurrences
contains(value) true if set contains ≥ 1 occurrence of value
count(value) returns # of occurrences of value; 0 if not
found
iterator() an object to examine all values in the set
remove(value) removes 1 occurrence of the given value; or
remove(value, count) removes the given # of occurrences
setCount(value, count) causes the given value to have the given count
size() returns sum of all counts
toString() string such as "[a x 4, b x 2, c]"
elementSet(), entrySet() collection views of the multiset

Multimap
• a map from keys to collections of values
– meant to replace Map<K, Set<V>> or Map<K, List<V>>
– implementations: ArrayListMultimap, LinkedListMultimap,
HashMultimap, LinkedHashMultimap, TreeMultimap

// political party -> people in it
Multimap<String, String> mmap = TreeMultimap.create();
mmap.put("D", "Gore");
mmap.put("D", "Clinton");

"R" [Obama, Kerry, Gore, Clinton]
"D" [Paul, Johnson]
"I" [Romney, McCain, Bush]
keys
values

See also com.google.common.collect.Multimap

Multimap methods
class.create() creates a new empty multimap,
class.create(map) or one based on the elements of a map
clear() removes all key/value pairs
containsKey(key) returns true if the given key is stored
get(key) returns collection of values associated with key
put(key, value) adds value to this key's collection
putAll(key, collection) adds all given values to this key's collection
remove(key, value) removes value from this key's collection
removeAll(key) removes all values associated with this key
size() returns number of key/value pairs
toString() string such as "{a=[b, c], d=[e]}"
asMap(), keys(), keySet(), various collection views of the map's data
values()

Choosing a Multimap
• The Multimap has two sub-ADT interfaces:
– ListMultimap  ArrayListMultimap, LinkedListMultimap
– SetMultimap  Hash, LinkedHash, TreeMultimap

• If you need list-specific methods, declare it as a
ListMultimap.

ListMultimap<String, String> mmap =
ArrayListMultimap.create();
mmap.put("D", "Gore");
mmap.put("D", "Clinton");
System.out.println(mmap.get("D").get(0); // Gore
System.out.println(mmap.get("D").get(1); // Clinton

BiMap(Bidirectional Map)
• a two-directional map
– for data where a b and also b a in symmetry
– avoids need to try to "invert" a map or store an inverse map
– implementations: HashBiMap
// state <--> state capital
BiMap<String, String> bmap = HashBiMap.create();
mmap.put("Arizona", "Phoenix");
mmap.put("Washington", "Olympia");

"Washington" "Sacramento"
"California" "Phoenix"
"Arizona" "Olympia"
keys values

See also com.google.common.collect.BiMap

Bimap Methods
• all methods from Map are present as well
– clear, containsKey, containsValue, equals, get,
isEmpty, keySet, put, putAll, remove, size, toString

class.create() creates a new empty bi-map,
class.create(map) or one based on the elements of a map
inverse() returns BiMap<V, K> in opposite direction
values() returns set of all values

Table
• a two-dimensional (key+key) / value structure
– meant to replace Map<R, Map<C, V>>
– a map stores pairs of form (K, V) where only K is known later;
a table stores triples of form (R, C, V) where R,C are known later
– implementations: HashBasedTable, TreeBasedTable,
ArrayTable
// (name + SSN => age)
Table<String, String, Integer> table =
TreeBasedTable.create();
table.put("Marty Stepp", "597-24-6138", 29);

name SSN age
Marty Stepp 597-24-6138 29
Stuart Reges 703-34-1593 84

See also com.google.common.collect.Table

Table Methods
class.create() creates a new empty table, etc.
cellSet() set of all (R, C, V) triples
clear() remove all values
column(C) returns column for given key as Map<R,V>
contains(R, C) true if table has a mapping for the given keys
containsRow(R), true if table has any mapping that includes the
containsColumn(C) given row or column key
get(R, C) returns value for the given keys, or null
isEmpty() true if there are no values
put(R, C, V) stores (R, C, V) triple in the table
putAll(table) adds all of the given table's data to this one
remove(R, C) removes any value mapped from the given keys
row(R) returns row for given key as a Map<C,V>
size() number of triples in table
toString() string such as "{a={b=c, d=e},f={g=h}}"

RangeSet
• a group of comparable ranges of values
– like a set, but you can add an entire range at a time
– implementations: TreeRangeSet
// teenagers and old people
RangeSet<Integer> ages = TreeRangeSet.create();
ages.add(Range.closed(13, 19));
ages.add(Range.atLeast(65));
System.out.println(rset.contains(15)); // true
System.out.println(rset.contains(72)); // true

<0 0 ... 12 13 ... 19 20 ... 64 ≥ 65 ...

See also com.google.common.collect.RangeSet

Specifying ranges
• Specify a range of values by calling static methods of the Range
class, each of which returns a Range object.

Range.closed(min, max) [min .. max] including both endpoints
Range.open(min, max) (min .. max) excluding min and max
Range.closedOpen(min, max) [min .. max) include min, exclude max
Range.openClosed(min, max) (min .. max] exclude min, include max
Range.atLeast(min) [min .. ∞) including min
Range.greaterThan(min) (min .. ∞) excluding min
Range.atMost(max) (-∞ .. max] including max
Range.lessThan(max) (-∞ .. max) excluding max
Range.all() all possible values, (-∞ .. ∞)
Range.singleton(value) [value]; just a single value

See also com.google.common.collect.Range

RangeSet Methods

class.create() creates a new empty range set, etc.
add(range) adds the given range of values
addAll(rangeset) adds all ranges from the given set
clear() removes all ranges
encloses(range) true if set contains the entire given range
enclosesAll(rangeset) true if set contains all ranges in given set
isEmpty() true if there are no ranges
remove(range) removes the given range of values
span() a Range representing all values in this set
subRangeSet(range) subset containing relevant ranges
toString() string such as "[1..3], (6..65]"

RangeMap
• like a range set, but stores (range, value) pairs
– implementations: TreeRangeMap
// body mass index -> description
RangeMap<Double, String> bmi =
TreeRangeMap.create();
bmi.put(Range.lessThan(18.5), "underweight");
bmi.put(Range.closedOpen(18.5, 25.0), "normal");
bmi.put(Range.closedOpen(25.0, 30.0), "overweight");
bmi.put(Range.atLeast(30.0), "obese");
System.out.println(bmi.get(27.1)); // "overweight"

< 18.5 18.5 .. 25.0 25.0 .. 30.0 ≥ 30.0
underweight normal overweight obese

See also com.google.common.collect.RangeMap

RangeMap Methods
class.create() creates a new empty range map, etc.
put(range, value) adds range/value pair
putAll(rangemap) adds all range/value pairs from given map
clear() removes all ranges
get(key) returns value for range containing key
isEmpty() true if there are no ranges
remove(range) removes all values in the given range
span() a Range representing all keys in this set
subRangeMap(range) submap containing relevant ranges
toString() string such as "{[1..3]=a, (6..65]=b}"

Other Cool Features
Static Constructors
Iterables
FluentIterable
MapMaker
Forwarding Decorators
Peeking Iterator
Abstract Iterator
Ordering

UTILITY CLASSES

Other Cool Features
• Collections2: utility methods related to all collections
• Lists: utility methods related to lists
• Sets: utility methods related to sets
• Queues: utility methods related to queues
• Multisets, Multimaps: utility methods related to multiset/map
• Tables: utility methods related to tables
• Iterables: utility methods related to collections and for-each
• Iterators: utility methods related to iterators and iteration
• Ranges: utility methods related to range/rangeset/rangemap
• Ordering: easy-to-create comparable and comparator orders

See also Guava's static collections utilities, explained.

Static Constructors
• Before
List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();

• After
List<TypeThatsTooLongForItsOwnGood> list = Lists.newArrayList();
Map<KeyType, LongishValueType> map = Maps.newLinkedHashMap();

• Initialize collections with their starting elements very conveniently
Set<Type> copySet = Sets.newHashSet(elements);
List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");

Iterables
• Helper class to work with classes implementing Iterable
• The overwhelming majority of operations in the Iterables class
are lazy
• There is a ”clone” class: Iterators with almost the same methods
as Iterables but working with Iterators
• Examples:
Iterable<Integer> concatenated = Iterables.concat(
Ints.asList(1, 2, 3),
Ints.asList(4, 5, 6));
// concatenated has elements 1, 2, 3, 4, 5, 6

String lastAdded = Iterables.getLast(myLinkedHashSet);

String theElement = Iterables.getOnlyElement(thisSetIsDefinitelyASingleton);
// if this set isn't a singleton, something is wrong!

Iterables Methods
• Traverse
– concat, consumingIteration, cycle, filter, transform, limit, skip, mergeSorted,
unmodifiableIterable (returns Iterable)
– paddedPartition, partition (returns Iterable<List<T>>)
• Querying:
– addAll, removeAll, removeIf, retainAll, retainIf, all, any, contains, isEmpty,
elementsEqual (returns boolean)
– size, frequency, advance, indexOf (returns int)
– toString (returns String)
• Converting:
– toArray (returns T[])
• Extracting:
– Find, get, getFirst, getLast, getOnlyElement, (returns T)
– tryFind (returns Optional<T>)

FluentIterable
FluentIterable is a rich interface for manipulating Iterable instances in a
chained fashion.
• Chaining (returns FluentIterable): skip, limit, cycle, filter, transform
• Querying (returns boolean): allMatch, anyMatch, contains, isEmpty
• Converting: to{List, Set, Map, SortedSet, SortedList}, toArray
• Extracting: first, last, firstMatch (returns Optional<E>), get (returns E)

Examples:
FluentIterable
.from(database.getClientList())
.transform(Functions.toStringFunction())
.limit(10)
.toList();

See also com.google.common.collect.FluentIterable.

MapMaker
• MapMaker is one of the jewels of com.google.common.collect.
• A builder of ConcurrentMap instances having any combination of
certain features.
ConcurrentMap<User, RecGraph> recommendations =
new MapMaker()
.concurrencyLevel(4)
.weakKeys()
.expiration(10, TimeUnit.MINUTES)
.makeComputingMap(
new Function<User, RecGraph>() {
public RecGraph apply(User user) {
return createExpensiveGraph(user);
}
}
);

• See documentation on com.google.common.collect.MapMaker.

• For all the various collection interfaces, Guava provides
Forwarding abstract classes to simplify using the decorator
pattern.
class AddLoggingList<E> extends ForwardingList<E> {
final List<E> delegate; // backing list
@Override protected List<E> delegate() {
return delegate;
}
@Override public void add(int index, E elem) {
log(index, elem);
super.add(index, elem);
}
@Override public boolean add(E elem) {
return standardAdd(elem); // implements in terms of add(int, E)
}
@Override public boolean addAll(Collection<? extends E> c) {
return standardAddAll(c); // implements in terms of add
}
}

Interface Forwarding Decorator
Collection ForwardingCollection
List ForwardingList
Set ForwardingSet
SortedSet ForwardingSortedSet
Map ForwardingMap
SortedMap ForwardingSortedMap
ConcurrentMap ForwardingConcurrentMap
Map.Entry ForwardingMapEntry
Queue ForwardingQueue
Iterator ForwardingIterator
ListIterator ForwardingListIterator
Multiset ForwardingMultiset
Multimap ForwardingMultimap
ListMultimap ForwardingListMultimap
SetMultimap ForwardingSetMultimap

Peeking Iterator
• a subtype of Iterator that lets you peek() at the element
• Iterators supports the method Iterators.peekingIterator(Iterator),
which wraps an Iterator and returns a PeekingIterator

• Remove consecutive duplicates:
List<E> result = Lists.newArrayList();
PeekingIterator<E> iter = Iterators.peekingIterator(source.iterator());
while (iter.hasNext()) {
E current = iter.next();
while (iter.hasNext() && iter.peek().equals(current)) {
// skip this duplicate element
iter.next();
}
result.add(current);
}

Abstract Iterator
• Implementing your own Iterator.
• Implement only one method, computeNext()
• wrap an iterator so as to skip null values:
public static Iterator<String> skipNulls(final Iterator<String> in) {
return new AbstractIterator<String>() {
protected String computeNext() {
while (in.hasNext()) {
String s = in.next();
if (s != null) {
return s;
}
}
return endOfData();
}
};
}

• Note: AbstractIterator extends UnmodifiableIterator, which forbids the
implementation of remove(). If you need an iterator that supports remove(), you
should not extend AbstractIterator.

Ordering(1/4)
Ordering is Guava’s “fluent” Comparator
class, which can be used to manipulate,
extend, and make use of comparators.

Quick examples:
Comparator<String> comparator = new Comparator<String>() {
public int compare(String left, String right) {
return Ints.compare(left.length(), right.length());
}
};
List<String> list = Lists.newArrayList(“1”, “2”, “3”);
if (Ordering.from(comparator).reverse().isOrdered(list)){…}

Ordering(2/4) - Creation
Using static factory methods:
• natural(): uses the natural ordering on Comparable types
• usingToString(): Compares Objects by the lexicographical
ordering of their string representations
• arbitary(): Returns an arbitrary ordering over all objects
• from(Comparator): Making a preexisting Comparator into
an Ordering

Ordering(3/4) - Manipulation
Ordering can be modified to obtain many other useful
derived orderings

• reverse()
• compound(Comparator)
• onResultOf(Function)
• nullsFirst()
• nullsLast()
• lexicographical()
– (yields an Ordering<Iterable<T>>!)

Ordering(4/4) - Application
“Guava provides a number of methods to manipulate or
examine values”

• immutableSortedCopy(Iterable)
• isOrdered(Iterable)
• isStrictlyOrdered(Iterable)
• min(Iterable)
• max(Iterable)
• leastOf(int, Iterable)
• greatestOf(int, Iterable)

Some are even optimized for the specific kind of comparator
you have.

Concurrency libraries
Monitor
ListenableFuture
Service
COM.GOOGLE.COMMON.UTIL.CONCURRENT
POWERFUL, SIMPLE ABSTRACTIONS TO MAKE IT EASIER TO WRITE
CORRECT CONCURRENT CODE.

First learn the contents of java.util.concurrent.

Then check out guava concurrency libraries:
• ListenableFuture<V>, ListeningExecutorService
• CheckedFuture<V, X>
• Service, ServiceManager
• RateLimiter
• ThreadFactoryBuilder
• MoreExecutors
• AtomicLongMap<K>
• AtomicDouble
• Uninterruptibles
• ...

Monitor
Synchronization with Monitor
• Monitor is a synchronization construct
that can be used anywhere you would
use a ReentrantLock.
• Only one thread can occupy a monitor at
any time.
• operations of entering and leaving which
are semantically the same as
the lock and unlock operations in
ReentrantLock

http://codingjunkie.net/google-guava-synchronization-with-monitor/

Monitor
ReenterantLock vs. Monitor

http://codingjunkie.net/google-guava-synchronization-with-monitor/

Monitor
Monitor Usage Guidelines
• Basic Case

• Condition Case

Methods Descriptions
tryEnterIf Enters this monitor if it is possible to do so immediately and the guard is satisfied. Does
not block acquiring the lock and does not wait for the guard to be satisfied.
enterIf Enters this monitor if the guard is satisfied. Blocks indefinitely acquiring the lock, but does
not wait for the guard to be satisfied.
enterWhen Enters this monitor when the guard is satisfied. Blocks indefinitely, but may be interrupted.

ListenableFuture – What?
• Future with one new method:
addListener(Runnable, Executor)
• When the future is done (success,
exception, cancellation), the listener
runs

ListenableFuture – Why?
• Callbacks?
service.process(request).addListener(new Runnable() {
public void run() {
try {
Result result = Futures.makeUninterruptible(future).get();
// do something with success |result|
} catch (ExecutionException ee) {
// do something with failure |ee.getCause()|
} catch (RuntimeException e) {
// just to be safe
}
}
}, executor);

service.process(new AsyncCallback<Result>() {
public void success(Result result) {
// do something with success |result|
}
public void failure(Exception e) {
// do something with failure |e|
}
}, executor);

ListenableFuture – Why?
• Aspects
future.addListener(new Runnable() {
public void run() {
processedCount.incrementAndGet();
inFlight.remove(name);
lastProcessed.set(name);
LOGGER.info("Done with %s", name);
}
}, executorService);

ListenableFuture – When?
• (+) Most Futures methods require it.
• (+) It's easier than changing to ListenableFuture
later.
• (+) Providers of utility methods won't need to
provide Future and ListenableFuture variants of
their methods.
• (−) "ListenableFuture" is lengthier than "Future."
• (−) Classes like ExecutorService give you a plain
Future by
• default.

ListenableFutuere – How?
• Create ListenableFuture instead of plain
Future:
• ExecutorService.submit(Callable) ➜
– Call MoreExecutors.listeningDecorator on
your executor.
• MyFutureTask.set(V) ➜
– Use SettableFuture.

ListenableFuture Example
ListeningExecutorService service = MoreExecutors.listeningDecorator(
Executors.newFixedThreadPool(10));

ListenableFuture<Explosion> explosion = service.submit(new Callable<Explosion>() {
public Explosion call() {
return pushBigRedButton();
}
});

Futures.addCallback(explosion, new FutureCallback<Explosion>() {
// we want this handler to run immediately after we push the big red button!
public void onSuccess(Explosion explosion) {
walkAwayFrom(explosion);
}
public void onFailure(Throwable thrown) {
battleArchNemesis(); // escaped the explosion!
}
});

Futures
ListenableFuture<RowKey> rowKeyFuture = indexService.lookUp(query);
AsyncFunction<RowKey, QueryResult> queryFunction =
new AsyncFunction<RowKey, QueryResult>() {
public ListenableFuture<QueryResult> apply(RowKey rowKey) {
return dataService.read(rowKey);
}
};
ListenableFuture<QueryResult> queryFuture = Futures.transform(rowKeyFuture, queryFunction, queryExecutor);

Method Description

transform(ListenableFuture<A>, A Returns a new ListenableFuture whose result is the product of applying the given AsyncFunctio
syncFunction<A, B>, Executor) n to the result of the givenListenableFuture.

transform(ListenableFuture<A>, F Returns a new ListenableFuture whose result is the product of applying the given Function to th
unction<A, B>, Executor) e result of the givenListenableFuture.

allAsList(Iterable<ListenableFuture Creates a new ListenableFuture whose value is a list containing the values of all its input futures,
<V>>) if all succeed. fails if any input fails

successfulAsList(Iterable<Listenabl Creates a new ListenableFuture whose value is a list containing the values of all its successful in
eFuture<V>>) put futures. succeeds, with null in place of failures

Service
• An object with an operational state, with
methos start and stop.

• e.g. web servers, RPC servers, monitoring
initialization, ...

Service - Lifecycle
• Lifecycle
– Service.State.NEW
– Service.State.STARTING
– Service.State.RUNNING
– Service.State.STOPPING
– Service.State.TERMINATED
• On Failure:
– Service.State.FAILED
A stopped service may not be restarted

Service – Lifecycle #2
• Asynchronously:
– start: returns ListenableFuture
– stop

• Synchronously:
– startAndWait
– stopAndWait

Service – AbstractIdleService
• AbstractIdleService
– skeleton implements a Service which does
not need to perform any action while in the
"running" state

protected void startUp() {
servlets.add(new GcStatsServlet());
}
protected void shutDown() {}

Service -
AbstractExecutionThreadService
• AbstractExecutionThreadService
– performs startup, running, and shutdown actions in
a single thread.
protected void startUp() {
dispatcher.listenForConnections(port, queue);
}
protected void run() {
Connection connection;
while ((connection = queue.take() != POISON)) {
process(connection);
}
}
protected void triggerShutdown() {
dispatcher.stopListeningForConnections(queue);
queue.put(POISON);
}

Service -
AbstractScheduledService
• AbstractScheduledService
– performs some periodic task while running
– Similar to AbstractionThreadService

• Override runOneIteration()
• Implement scheduler()
– newFixedRateSchedule
– newFixedDelaySchedule

First learn the contents of
java.util.concurrent.

Then check out guava concurrency libraries:
• CheckedFuture<V, X>
• Service, ServiceManager
• RateLimiter
• ThreadFactoryBuilder
• AtomicLongMap<K>
• AtomicDouble
• Uninterruptibles
• ...

Why a new hashing API?
JDK solution
Hashing Overview
Bloom Filter
COM.GOOGLE.COMMON.HASH
TOOLS FOR MORE SOPHISTICATED HASHES THAN WHAT'S
PROVIDED BY OBJECT.HASHCODE(), INCLUDING BLOOM FILTERS

Why a new hashing API?
• Object.hashCode() implementations tend to be very
fast, but:
– Strictly limited to 32 bits
– Worse, composed hash codes are "collared" down to
32bits during the computation
– No separation between "which data to hash" and "which
algorithm to hash it with"
– Implementations have very bad bit dispersion

• These make it not very useful for a multitude of
hashing applications: a document "fingerprint",
cryptographic hashing, cuckoo hashing, Bloom
filters...

JDK solution
To address this shortcoming, the JDK introduced
two interfaces:
– java.security.MessageDigest
– java.util.zip.Checksum

Each named after a specific use case for hashing.

Worse than the split: neither is remotely easy to
use when you aren't hashing raw byte arrays.

Guava Hashing Example
HashFunction hf = Hashing.murmur3_128();
HashCode hc = hf.newHasher()
.putLong(id)
.putInt(age)
.putString(name)
.putBytes(someBytes)
.putObject(person, personFunnel)
.hash();

HashCode has asLong(), asBytes(), toString()...

Or put it into a Set, return it from an API, etc.
(It also implements equals() in a special way.)

See the documentation on com.google.common.hash.HashCode and
com.google.common.hash.Hashing.

Hashing Overview
The com.google.common.hash API offers:

• A unified user-friendly API for all hash functions
• Seedable 32- and 128-bit implementations of
murmur3
• md5(), sha1(), sha256(), sha512(), murmur3_128(),
murmur3_32() adapters
– change only one line of code to switch between these
and murmur etc.
• goodFastHash(int bits), for when you don't care what
algorithm you use
• General utilities for HashCode instances, like
combineOrdered / combineUnordered

BloomFilter
A probabilistic set.
• public boolean mightContain(T);
– true == "probably there"
– false == "definitely not there"
WHY? Consider a spell-checker:
– If syzygy gets red-underlined, that's annoying
– But if yarrzcw doesn't get red-underlined... oh well!
– And the memory savings can be very large
Primary use: short-circuiting an expensive boolean query

BloomFilter<Person> friends = BloomFilter.create(personFunnel, 500, 0.01);
for(Person friend : friendsList) {
friends.put(friend);
}
// much later
if (friends.mightContain(dude)) {
// the probability that dude reached this place if he isn't a friend is 1%
// we might, for example, start asynchronously loading things for dude while we do a more
expensive exact check
}

Immutable collections
New collection types
Powerful collection utilities
Extension utilities
COM.GOOGLE.COMMON.CACHE
LOCAL CACHING, DONE RIGHT, AND SUPPORTING A WIDE
VARIETY OF EXPIRATION BEHAVIORS.

Caching
• Guava has a powerful on-heap key→value cache.

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.removalListener(MY_LISTENER)
.build(
new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
return createExpensiveGraph(key);
}
});

Caches – Population
• From CacheLoader
.maximumSize(1000)
.build( new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
} });
...
try {
return graphs.get(key);
} catch (ExecutionException e) {
throw new OtherException(e.getCause());
}

• From Callable
.expireAfterAccess(10, TimeUnit.MINUTES)
.build(
public Graph load(Key key) { // no checked exception
}
});
...
return graphs.getUnchecked(key);

Eviction #1
• By Size:
– CacheBuilder.maximumSize(long)
• By custom weight:
– CacheBuilder.weighter(Weighter)
– CacheBuilder.maximumWeight(long)
.maximumWeight(100000)
.weigher(new Weigher<Key, Graph>() {
public int weigh(Key k, Graph g) {
return g.vertices().size();
}
})
.build(
public Graph load(Key key) { // no checked exception
}
});

Eviction #2
• By Time:
– expireAfterAccess(long, TimeUnit)
– expireAfterWrite(long, TimeUnit)

• By Testing Timed:
– CacheBuilder.ticker(Ticker)

Eviction #3
• By Reference-based:
– CacheBuilder.weakKeys()
– CacheBuilder.weakValues()
– CacheBuilder.softValues()

• Note: all of them are using == for
equality and *not* equals()

Eviction #4
• By Explicit:
– Cache.invalidate(key)
– Cache.invalidateAll(keys)
– Cache.invalidateAll()

Removal Listeners
• CacheBuilder.removalListener(RemovalListener)

• Be aware of long running listeners. They are blocking the queue.

• CacheBuilder.asynchronous(RemovalListener, Executor)
CacheLoader<Key, DatabaseConnection> loader = new CacheLoader<Key, DatabaseConnection> () {
public DatabaseConnection load(Key key) throws Exception {
return openConnection(key);
}
};
RemovalListener<Key, DatabaseConnection> removalListener = new RemovalListener<Key, DatabaseConnection>() {
public void onRemoval(RemovalNotification<Key, DatabaseConnection> removal) {
DatabaseConnection conn = removal.getValue();
conn.close(); // tear down properly
}
};
return CacheBuilder.newBuilder()
.expireAfterWrite(2, TimeUnit.MINUTES)
.removalListener(removalListener)
.build(loader);

Cleanup
• Caches built with CacheBuilder do not perform cleanup and evict
values "automatically“, or instantly after a value expires, or
anything of the sort.
• it performs small amounts of maintenance during write
operations, or during occasional read operations if writes are rare

• Automatic eviction happens on writes Explicit Cache.cleanup()

com.google.common.math
com.google.common.io
com.google.common.eventbus
com.google.common.net
com.google.common.reflect

OTHERS

Math
• Convenience classes to perform some common
mathematical calculations

• Available classes: IntMath, LongMath, DoubleMath,
and BigIntegerMath

• The utility classes support overflow-aware arithmethics,
so that no silent overflows occur.

• Also see Guava's math utilities, explained.

Math Examples

// Checked arithmetic operations
int bigNumber = IntMath.checkedAdd(Integer.MAX_VALUE, 1); // throws ArithmeticException

// Defining RoundingMode for arithmetic operations
IntMath.divide(10, 4, RoundingMode.HALF_UP); // -> 3
IntMath.divide(10, 4, RoundingMode.HALF_DOWN); // -> 2
IntMath.divide(10, 4, RoundingMode.UNNECESSARY); // throws ArithmeticException

// Common numerical operations
IntMath.gcd(20, 15); // -> 5
IntMath.factorial(4); // -> 24
IntMath.log10(100, RoundingMode.UNNECESSARY); // -> 2

I/O
• If what you need pertains to streams, buffers, files and
the like, look to the package com.google.common.io.
In parts similar to Apache Commons I/O.
• Key interfaces:
public interface InputSupplier<T> {
T getInput() throws IOException; // T is typically an InputStream, a Reader, etc.
}

public interface OutputSupplier<T> {
T getOutput() throws IOException; // T is typically an OutputStream, a Writer, etc.
}

• Typically: InputSupplier<InputStream>, OutputSupplier
<Writer>, etc. This lets all the utility classes be useful
for many kinds of I/O.
• Also see Guava's I/O package utilities, explained.

Streams
Terminology:
• byte stream means "InputStream or OutputStream"
• char stream means "Reader or Writer."

Utilities for these things are in the classes ByteStreams
and CharStreams (which have largely parallel structure).

ByteStreams
• byte[] toByteArray(InputStream)
• byte[] toByteArray(InputSupplier)
• void readFully(InputStream, byte[])
• void write(byte[], OutputSupplier)
• long copy(InputStream, OutputStream)
• long copy(InputSupplier, OutputSupplier)
• long length(InputSupplier)
• boolean equal(InputSupplier, InputSupplier)
• InputSupplier slice(InputSupplier, long, long)
• InputSupplier join(InputSupplier...)

CharStreams is similar, but deals in Reader, Writer, String and
CharSequence (often requiring you to specify a Charset).

See the documentation on com.google.common.io.ByteStreams and
com.google.common.io.CharStreams.

Files
• The Files class works one level higher
than ByteStreams and CharStreams, and has a few other tricks.
• In parts superseeded by the NIO.2 classes in JDK 7 or higher.

• byte[] toByteArray(File)
• String toString(File, Charset)
• void write(byte[], File)
• void write(CharSequence, File, Charset)
• long copy(File, File)
• long copy(InputSupplier, File)
• long copy(File, OutputSupplier)
• long copy(File, Charset, Appendable)
• long move(File, File)
• boolean equal(File, File)
• List<String> readLines(File, Charset)

Overview
Classes from the eventbus package can be used as a simple tool to
implement an in-memory publish-subscrib use case

Besides standard features these classes have some extras:
• checking if someone is listening for an event of given type
• events hierarchy

There are two variants for the event bus:
• EventBus (synchronous)
• AsyncEventBus (asynchronous)

See the documentation on com.google.common.eventbus

Examples:Listener
Listener class needs only one additional element, a method
annotated with@Subscribe.
Argument of this method defines what type of event this class is
listening for.
There are no restrictions to be an event class. It could also just be
a String orInteger.
One listener can subscribe (listen for) more than one type of event.
public class MyListener {
@Subscribe
public listen(Integer event) {
// ...
}
}

See the documentation on com.google.common.eventbus.Subscribe

Examples:EventBus
EventBus eventBus = new EventBus("example");
MyListener listener = new MyListener();

eventBus.register(listener);

eventBus.post(42);
// EventBus synchronously calls listener.listen(42)

• See the document on Guava's event bus utility, explained.

DeadEvent
To handle events without any listener we can use the pre-
defined DeadEvent.

A DeadEvent is posted when the EventBus receives an event without
any listeners to it.

In such situation we can, for example, log a warning message to a
log file.

See the documentation on com.google.common.eventbus.DeadEvent

com.google.common.net
Classes in com.google.common.net
• work with literals of: URI, URL, IP(v4/v6)
• never cause DNS services to be accessed (JDK does…)

Examples:
• HostSpecifier: syntactically valid host specifier, suitable for use in
a URI
• InternetDomainName: RFC 1035, i18n domain names
• InetAddresses: utility class pertaining to Inet(4|6)Address instances
• HttpHeaders: constant definitions for the HTTP header field
names
• MediaType: an Internet Media Type (also known as a MIME Type
or Content Type)

com.google.common.reflect
Here be dragons!

Utility classes to work with Java reflection.

Please don't use reflection if you're not writing a library. It will lead to breakage
at runtime.

• TypeToken
• TypeToInstanceMap (ImmutableTypeToInstanceMap, MutableTypeToInstanceMap)
• Types
• TypeResolver
• ClassPath
• Reflection
• Invokable (ConstructorInvokable, MethodInvokable)
• Parameter

Also see Guava's new reflection utilities, explained.

com.google.common.annotations

• Beta
• VisibleForTesting
• GWTCompatible
• GWTIncompatible

Also see com.google.common.annotations

Reference
• Guava on Google Code

• http://www.tfnico.com/presentations/google-guava
• Google Guava- juice up your java
• Using The Google Collections Library For Java
• Silicon Valley Java Users Group Sept 2012 presentation slides
• DevoxxFR 2012 presentation slides
• Caching presentation from Devoxx France 2012
• Guava util.concurrent presentation
• Guava presentation (@ Netflix)

• Collection presentation from Washington University lecture
• Introduction to google guava[KOR]
• Google guava - almost everything you need to know
• Guava Overview. Part 1 @ Bucharest JUG #1
• Guava Overview Part 2 Bucharest JUG #2
• http://bhavintechspace.blogspot.de/2012/12/google-guava-introduction.html

Google guava overview

More Related Content

Google guava overview