Google Guava - Core libraries for Java & Android

Google Guava
Core libraries for Java & Android
@jordi9
11 / oct / 2013

...shameless self-promotion bro!

Basics: Avoid using null
“Null sucks”
Doug Lea - JCP, OpenJDK

“I call it my billion-dollar mistake”
Sir C.A.R. Hoare - Inventor of null

@Google
95% of collections weren’t supposed
to have null values.

map = {Foo: bar, null, Baz: qux}

map.get(“Foo”);

map.get(“Foo”); // returns Foo

map.get(“Foo”);
map.get(“quux”);

map.get(“Foo”);
map.get(“quux”); // returns null

map.get(“Foo”);
map.get(null);

map.get(“Foo”);
map.get(null); // returns null

map.get(“Foo”);

map.get(“Foo”);
// Null to indicate absence
// vs null value

Optional<T>

Optional<T>
Optional<String> foo = Optional.of(“foo”)

Optional<T>
foo.isPresent(); // returns true

Optional<T>
foo.isPresent();
foo.get(); // returns “foo”

Optional.of(foo); // not nullable
Goodies!
RTFM, I mean javadoc

Optional.of(foo);
Optional.absent();
Goodies!
javadoc

Optional.of(foo);
Optional.absent();
Optional.fromNullable(legacyCode);
Goodies!
javadoc

Optional.of(foo);
Optional.absent();
foo.get(); // may return “foo”
Goodies!
javadoc

Optional.of(foo);
Optional.absent();
foo.get();
foo.or(“bar”); // return “bar” if foo is absent
Goodies!
javadoc

Optional.of(foo);
Optional.absent();
foo.get();
foo.or(“bar”);
foo.orNull(); // Deal with code that need nulls, duh
Goodies!
javadoc

Optional<T> is IDIOT-PROOF-NESS
Bottom line

if (seats <= 0) {
throw new IllegalArgumentException(“Seats must be
positive, but was ” + seats);
}
Basics: Preconditions

if (seats <= 0) {
throw new IllegalArgumentException(“Seats must be
positive, but was ” + seats);
}
checkArgument(seats > 0, “Seats must be positive,
but was %s”, seats);

// Always use static import
import static com.google.common.base.Preconditions.checkArgument;

// Check what you expect to be true

// “%s” specifier is recognized as a placeholder in
// these messages (the only one)

void execute(Job job) {
// serious business
}

checkNotNull(job, “Job can’t be null”);
// serious business
}
// checkNotNull() throws NullPointerException

checkArgument(!job.started(), “Job already started”);
// serious business
}
// checkArgument() throws IllegalArgumentException

checkArgument(!job.started(), “Job already started”);
// serious business
checkState(seatsAvailabe <= totalSeats, “You’ve sold
more seats than available! This should never
happen. %s/%s”, seatsAvailable, totalSeats);
}
// checkState() throws IllegalStateException
// checkArgument() throws IllegalArgumentException

this.foo = checkNotNull(foo); // inline assig
Goodies!
javadoc

this.foo = checkNotNull(foo);
// list, string or array checks
checkElementIndex(index, size);
checkPositionIndex(index, size);
checkPositionIndexes(start, end, size);
Goodies!
javadoc

Preconditions will save your ass
Bottom line

@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
Person guest = (Person) obj;
return id == guest.id
&& (firstName == guest.firstName || (firstName != null &&
firstName.equals(guest.getFirstName())))
&& (lastName == guest.lastName || (lastName != null &&
lastName.equals(guest.getLastName())));
}
Basics: Objects

@Override
if (obj == this) {
return true;
}
return false;
}
}
Basics: Objects
F

@Override
if (obj == this) {
return true;
}
return false;
}
}
Basics: Objects
FM

@Override
if (obj == this) {
return true;
}
return false;
}
}
Basics: Objects
FML

@Override
if (obj instanceof Person) {
Person that = (Person) obj;
return Objects.equal(firstName, that.firstName)
&& Objects.equal(lastName, that.lastName);
} else {
return false;
}
}
Basics: Objects

@Override
return Objects.equal(firstName, that.firstName) // null safe!
&& Objects.equal(lastName, that.lastName); // null safe x2!
} else {
return false;
}
}
Basics: Objects

@Override
return Objects.equal(firstName, that.firstName)
&& Objects.equal(lastName, that.lastName);
} else {
return false;
}
}
// JDK 1.7 introduced equivalent Objects.equals() method.
Basics: Objects

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((firstName == null) ? 0 : firstName.hashCode());
result = prime * result + id;
+ ((lastName == null) ? 0 : lastName.hashCode());
return result;
}
Basics: Objects

@Override
final int prime = 31;
int result = 1;
+ ((firstName == null) ? 0 : firstName.hashCode());
result = prime * result + id;
+ ((lastName == null) ? 0 : lastName.hashCode());
return result;
}
// oh, grumpy cat!
Basics: Objects

@Override
return Objects.hashCode(firstName, lastName);
}
Basics: Objects

@Override
// sensible, order-sensitive hash
}
Basics: Objects

@Override
}
// JDK 1.7 introduced equivalent Objects.hash() method.
Basics: Objects

@Override
public String toString() {
}
Basics: Objects

@Override
return Objects.toStringHelper(this)
.add("firstName", firstName)
.add("lastName", lastName)
.add("catName", catName)
.toString();
}
Basics: Objects

@Override
.toString();
}
// returns Person{firstName=Solid, lastName=Snake, catName=null}
Basics: Objects

@Override
.omitNullValues()
.toString();
}
Basics: Objects

@Override
.omitNullValues()
.toString();
}
// returns Person{firstName=Solid, lastName=Snake}
Basics: Objects

IntelliJ IDEA support for ToStringHelper()
Generate toString() > Template Objects.ToStringHelper (Guava)
Goodies!
javadoc

So common stuff should ring a bell
Bottom line

Comparator<Person> byDescAgeName = new Comparator<Person>() {
public int compare(Person p1, Person p2) {
int result = p2.getAge() - p1.getAge(); // ugh!
return (result == 0) ?
p1.compareTo(p2) : result;
}
};
// Ok, it’s not that bad -- But it’s pretty hard to get
Basics: Ordering

int result = p2.getAge() - p1.getAge(); // ugh!
return (result == 0) ?
p1.compareTo(p2) : result;
}
};
// Ok, it’s not that bad -- But it’s pretty hard to get
// We’re lucky ints and Person are Comparable, otherwise you’ll
// have to implement it
Basics: Ordering

return ComparisonChain.start()
.compare(p2.getAge(), p1.getAge())
.compare(p1, p2)
.result();
}
};
Basics: Ordering

return ComparisonChain.start()
.compare(p2.getAge(), p1.getAge())
.compare(p1, p2)
.result();
}
};
// Short-circuits: If one comparison is not equals, stop and return
Basics: Ordering

Comparator<Person> byDescAgeName =
Ordering.natural()
.reverse()
.onResultOf(new Function<Person, Integer>() {
public Integer apply(Person person) {
return person.getAge();
}})
.compound(Ordering.natural());
}
};
Basics: Ordering

Comparator<Person> byDescAgeName =
Ordering.natural()
.reverse()
.onResultOf(new Function<Person, Integer>() {
public Integer apply(Person person) {
return person.getAge();
}})
.compound(Ordering.natural());
}
};
// Read backwards
Basics: Ordering

Ordering is an “enriched” Comparator. It’s fuuuuuuuun!
Goodies!
javadoc

Ordering is an “enriched” Comparator. It’s fluent.
Goodies!
javadoc

// Subclass Ordering and implement compare(T,T)
Ordering<Throwable> ORDER_BY_CLASS_NAME = (left, right) -> {
return Ordering.usingToString()
.compare(left.getClass(), right.getClass());
};
Goodies!
javadoc

};
// Or create one
Ordering.from(comparator);
Ordering.natural();
Goodies!
javadoc

};
// Or create one
Ordering.from(comparator);
Ordering.natural();
// And chain!
ORDER_BY_CLASS_NAME.nullsFirst().reverse().compound(comparator);
Goodies!
javadoc

There’s a better way than Comparator
Bottom line

void oneLineOfCode() {
DatagramPacket packet = new DatagramPacket(data, length);
}
Basics: Throwables

}
// Compile error, throws IOException
Basics: Throwables

void oneLineOfCode() throws IOException {
}
void someLayer() {
oneLineOfCode();
}
Basics: Throwables

}
void someLayer() {
oneLineOfCode();
}
// Compile error, throws IOException
Basics: Throwables

}
void someLayer() throws IOException {
oneLineOfCode();
}
void someCoolAbstraction() {
someLayer();
}
Basics: Throwables

}
oneLineOfCode();
}
void someCoolAbstraction() {
someLayer();
}
// Compile error, AGAIN
Basics: Throwables

}
oneLineOfCode();
}
void someCoolAbstraction() throws IOException {
someLayer();
}
Basics: Throwables

DatagramPacket packet = new DatagramPacket(data, address);
}
oneLineOfCode();
}
void someCoolAbstraction() throws IOException {
someLayer();
}
// c’mon...
Basics: Throwables

// Take 2
}
Basics: Throwables

try {
} catch (IOException e) {
}
}
Basics: Throwables

try {
// Really? Swallow? Sure? At least explain why!
}
}
Basics: Throwables

try {
SendMeAnEmail.error();
}
}
Basics: Throwables

try {
Oh.theLogger().fatal(“WHY Y U FATAL NOW?”);
}
}
Basics: Throwables

try {
// repeat for every catch block
}
}
Basics: Throwables

try {
// AGAIN AND AGAIN
}
}
Basics: Throwables

try {
DatagramPacket packet = new DatagramPacket(data, address);
// AGAIN AND AGAIN
}
}
Basics: Throwables

// Take 3
}
Basics: Throwables

try {
handle(e);
}
}
// We know what to do with this Exception, like recover
Basics: Throwables

try {
throw new MyException(e);
}
}
// Translate the Exception to another one more suitable
Basics: Throwables

try {
throw Throwables.propagate(e);
}
}
// Propagates the throwable as-is if it is a RuntimeException or
// an Error, or wraps it in a RuntimeException and throws it
// otherwise.
Basics: Throwables

// more forms
propagateIfInstanceOf(throwable,exceptionClass);
Goodies… or gotcha’s!
javadoc

// more forms
propagateIfPossible(throwable); // Only if RuntimeException or Error
javadoc

// more forms
propagateIfPossible(throwable);
propagateIfPossible(throwable, exceptionClass);
javadoc

// more forms
General practice:
Convert checked exceptions to unchecked exceptions
javadoc

// more forms
General practice:
Checked exceptions... are a bad idea?
javadoc

// more forms
General practice:
Checked exceptions... are a bad idea?
Don’t use propagate() to ignore IOExceptions and so on
javadoc

Think your fraking Exceptions
Bottom line

We have String.split bro!
Strings: Splitter

“,f,,o, o,”.split(“,”) returns:
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
b. [null, “f”, null, “o” ,”o”, null]
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
c. [“f”, null, “o”, “o”]
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
c. [“f”, null, “o”, “o”]
d. [“f”, ”o”, ”o”]
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
c. [“f”, null, “o”, “o”]
d. [“f”, ”o”, ”o”]
e. None of above
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
c. [“f”, null, “o”, “o”]
d. [“f”, ”o”, ”o”]
e. None of above
Returns: [“”, “f”, “”, “o”, “ o”]
Strings: Splitter

a. [“”, “f”, “”, “o”, “ o”,””]
c. [“f”, null, “o”, “o”]
d. [“f”, ”o”, ”o”]
e. None of above
Returns: [“”, “f”, “”, “o”, “ o”]
Only trailing empty strings are skipped.
Strings: Splitter

“,f,,o, o,”.split(“,”) we probably want [“f”,”o”,”o”]
Strings: Splitter

Splitter.on(‘,’)
.split(“,f,,o, o,”);
Strings: Splitter

// returns [“”,”f”,””,”o”,” o”,””]
// Doesn’t discard trailing separators!
Strings: Splitter

.omitEmptyStrings()
Strings: Splitter

.omitEmptyStrings()
// returns [”f”,”o”,” o”]
// Empty space is respected
Strings: Splitter

.omitEmptyStrings()
.trimResults()
Strings: Splitter

.omitEmptyStrings()
.trimResults()
// returns [”f”,”o”,”o”] -- yay!
Strings: Splitter

static final Splitter COMMA = Splitter.on(‘,’)
.omitEmptyStrings()
.trimResults()
// Best practice: declare Splitters as static final
Strings: Splitter
javadoc

[“Jack, “Chloe”, “Tony”, null, “Nina”, “Logan”]
Strings: Joiner

Joiner.on(“, “)
.join(twentyFour);
Strings: Joiner

Joiner.on(“, “)
.join(twentyFour);
// throws NullPointerException!
Strings: Joiner

Joiner.on(“, “)
.join(twentyFour);
// throws NullPointerException!
// null-hostile operations everywhere, good thing ;)
Strings: Joiner

Joiner.on(“, “)
.skipNulls();
.join(twentyFour);
// returns “Jack, Chloe, Tony, Nina, Logan”
Strings: Joiner

Joiner.on(“, “)
.useForNull(“Bill”);
.join(twentyFour);
// returns “Jack, Chloe, Tony, Bill, Nina, Logan”
Strings: Joiner
javadoc

Always think how to avoid null-idioty
Bottom line

Your StringUtils replacement
Strings: CharMatcher

CharMatcher.JAVA_ISO_CONTROL.removeFrom(string); // remove control chars

CharMatcher.JAVA_ISO_CONTROL.removeFrom(string);
CharMatcher.DIGIT.retainFrom(“jordi9”); // returns 9

CharMatcher.DIGIT.retainFrom(“jordi9”);
CharMatcher.DIGIT.removeFrom(“jordi9”); // returns jordi

CharMatcher.DIGIT.retainFrom(“jordi9”);
CharMatcher.DIGIT.removeFrom(“jordi9”);
CharMatcher.DIGIT.or(CharMatcher.JAVA_UPPER_CASE).retainFrom(“Jordi9”);
// returns J9

// More matchers
CharMatcher.ANY;
CharMatcher.BREAKING_WHITESPACE;
CharMatcher.WHITESPACE;
CharMatcher.INVISIBLE;
CharMatcher.DIGIT; // Unicode
CharMatcher.JAVA_DIGIT; // Java’s definition
CharMatcher.is(char);
CharMatcher.isNot(char);
Goodies!
javadoc

// More matchers
CharMatcher.ANY;
CharMatcher.BREAKING_WHITESPACE;
CharMatcher.WHITESPACE;
CharMatcher.INVISIBLE;
CharMatcher.DIGIT; // Unicode
CharMatcher.JAVA_DIGIT; // Java’s definition
CharMatcher.is(char);
CharMatcher.isNot(char);
// And operations
.replaceFrom(charSequence, replacement);
.collapseFrom(charSequence, replacement);
.trimFrom(charSequence, replacement);
Goodies!
javadoc

HtmlEscapers.htmlEscaper().escape("Foo > bar");
// returns Foo > bar
Escapers

XmlEscapers.xmlAttributeEscaper().escape("foo "bar"");
// returns foo "bar"
Escapers

XmlEscapers.xmlContentEscaper().escape("foo "bar"");
// returns foo “bar”
Escapers

XmlEscapers.xmlContentEscaper().escape("foo "bar"");
Escaper myEscaper = Escapers.builder() // custom Escaper
.addEscape(‘’’, “‘’”)
.addEscape(‘&’, “&”)
.build();
Escapers
javadoc

Function<String, Integer> lengthFunction = new Function<String, Integer>() {
public Integer apply(String string) {
return string.length();
}
};
Predicate<String> allCaps = new Predicate<String>() {
public boolean apply(String string) {
return CharMatcher.JAVA_UPPER_CASE.matchesAllOf(string);
}
};
Multiset<Integer> lengths = HashMultiset.create(
Iterables.transform(Iterables.filter(strings, allCaps), lengthFunction));
Collections: Functional Idiom

Multiset<Integer> lengths = HashMultiset.create();
for (String string : strings) {
if (CharMatcher.JAVA_UPPER_CASE.matchesAllOf(string)) {
lengths.add(string.length());
}
}

}
}
// Use Imperative, you’ve already survived!

}
}
// Use Imperative, you’ve already survived!
// Wait for Java 8!
explain

Immutable = Thread-safe
Collections: Immutable types

static final ImmutableSet<String> FOO_NAMES =
ImmutableSet.of(“foo”, “bar”, “baz”);

// ImmutableList, ImmutableMap...

ImmutableList<String> defensiveCopy =
ImmutableList.copyOf(someList);

ImmutableList<String> defensiveCopy =
ImmutableList.copyOf(someList);
// Prefer Immutable collections over JDK Collections.unmodifiableXX
// for efficiency and consistency
explain

A bag
Collections: Multiset<E>

A bag
Just like a Set<E> with repeated values

A bag
You’ve done this with ArrayList<E> or Map<E, Integer>

A bag
Multiset<Person> ppl = HashMultiset.create();

A bag
ppl.add(jack);
ppl.add(charles);
ppl.add(jack);

A bag
ppl.add(jack);
ppl.add(charles);
ppl.add(jack);
// prints [jack x 2, charles x 1]

A bag
ppl.add(jack);
ppl.add(charles);
ppl.add(jack);
ppl.count(jack);

A bag
ppl.add(jack);
ppl.add(charles);
ppl.add(jack);
ppl.count(jack);
// returns 2

A bag
ppl.add(jack);
ppl.add(charles);
ppl.add(jack);
ppl.count(jack);
// Goodies: elementSet(), entrySet(), setCount(E, int)...
explain

A Map<K, V> with multiple values
Collections: Multimap<K, V>

You’ve done this with Map<K, List<V>>

Multimap<Person, Ticket> ticketsByPerson =
ArrayListMultimap.create();

ticketsByPerson.put(jack, ctu);
ticketsByPerson.put(jack, division);

ticketsByPerson.get(jack);
// returns a view of the associated values, a List.
// With SetMultimap returns a Set.

ticketsByPerson.get(jack);
// asMap(), entries(), values()...
explain

// Bi-directional map, keys and values are unique
BiMap<K1, K2>
Goodies!
javadoc

BiMap<K1, K2>
// Two-tier map, or a map with two keys
Table<R, C, V>
Goodies!
javadoc

BiMap<K1, K2>
Table<R, C, V>
// < JDK 7, no diamond support
List<String> list = Lists.newArrayList(); // Sets, Maps...
Goodies!
javadoc

BiMap<K1, K2>
Table<R, C, V>
// < JDK 7, no diamond support
List<String> list = Lists.newArrayList(); // Sets, Maps...
// Ranges
RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10)); // {[1, 10]}
Goodies!
javadoc

Tons of good abstractions for you to use
Bottom line

Freaking PHP: md5($string)
Hashing: JDK

Freaking PHP: md5($string)
public static String md5Java(String message) {
String digest = null;
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] hash = md.digest(message.getBytes("UTF-8"));
String StringBuilder sb = new StringBuilder(2*hash.length);
for(byte b : hash){
sb.append(String.format("%02x", b&0xff));
}
digest = sb.toString();
} catch (UnsupportedEncodingException ex) {
throw Throwables.propagate(ex);
} catch (NoSuchAlgorithmException ex) {
throw Throwables.propagate(ex);
}
return digest;
}
Hashing: JDK

HashFunction hf = Hashing.md5();
Hashing: Hasher

HashCode hc = hf.newHasher()
.putLong(id)
.putString(name, Charsets.UTF_8)
.putObject(person, personFunnel)
.hash();
Hashing: Hasher

.putLong(id)
.putObject(person, personFunnel) // Defines how to hash
.hash();
Hashing: Hasher

.putLong(id)
.putString(name, Charsets.UTF_8) // HINT: remember this!
.hash();
Hashing: Hasher

.putLong(id)
.hash();
hc.asBytes(); // byte[]
hc.asInt(); // value in little-endian order
hc.toString(); // hexadecimal in lower case
Hashing: Hasher

// More hash functions!
Hashing.md5();
Hashing.murmur3_32();
Hashing.sha1();
Hashing.sha256();
Hashing.sha512();
Goodies!
javadoc

// More hash functions!
Hashing.md5();
Hashing.sha1();
Hashing.sha256();
Hashing.sha512();
// Bloom Filter
public boolean mightContain(T);
if true, T is probably there
if false, T for sure is not there
Goodies!
javadoc

Binary encoding scheme, RFC 4648
I/O: BaseEncoding

Binary encoding scheme, RFC 4648 -- Serious stuff
I/O: BaseEncoding

BaseEncoding
.base32()
.encode("foo".getBytes(Charsets.US_ASCII));
I/O: BaseEncoding

BaseEncoding
.base32()
// returns MZXW6===
I/O: BaseEncoding

BaseEncoding
.base32()
// returns MZXW6===
byte[] decoded = BaseEncoding
.base32()
.decode("MZXW6===");
I/O: BaseEncoding

BaseEncoding
.base32()
// returns MZXW6===
byte[] decoded = BaseEncoding
.base32()
.decode("MZXW6===");
// returns the ASCII bytes of String “foo”
I/O: BaseEncoding

// More schemas
BaseEncoding.base16();
BaseEncoding.base64Url(); // Useful all the time
Goodies!
javadoc

KIA
Caches
Networking
EventBus
Concurrency

KIA
Caches
Networking
Math
EventBus
Concurrency
More I/O

KIA
Caches
Networking
Math
Reflection
EventBus
Concurrency
More I/O
Collect

KIA
Caches
Networking
Math
Reflection
Primitives
EventBus
Concurrency
More I/O
Collect
Grumpy

Remember
No Grumpy Cats were
harmed in the making of
this presentation

Thanks!
jordi@donky.org
@jordi9

Google Guava - Core libraries for Java & Android

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Google Guava - Core libraries for Java & Android

Similar to Google Guava - Core libraries for Java & Android (20)

More from Jordi Gerona

More from Jordi Gerona (7)

Recently uploaded

Recently uploaded (20)

Google Guava - Core libraries for Java & Android