Google guava

Some quick examples of Google Guava, mostly in the base package.

1. Google Guava
Thomas Ferris Nicolaisen
@tfnico
www.tfnico.com
Code at http://github.com/tfnico/guava-examples

2. So much goodness in here...
•com.google.common.annotation
•com.google.common.base
•com.google.common.collect
•com.google.common.io
•com.google.common.net
•com.google.common.primitives
•com.google.common.util.concurrent

3. import com.google.common.annotations.*; /**
* An annotation that indicates that the visibility of a type or member has
* been relaxed to make the code testable.
*
*/
public @interface VisibleForTesting
/**
* Use this method for determining that a cart item is eligible for retail
pickup.
*
* @param item with productClass PRINT, or exportName "INDEXPRINT"
* @return true if it is allowed, false if not
*/
@VisibleForTesting
static boolean allowedForRetailPickup( final CartItem item) {
...

4. @Test
public void charSetsAndDefaults()
{
// Here's some charsets
Charset utf8 = Charsets. UTF_8;
assertTrue(utf8.canEncode());
// Primitive defaults:
Integer defaultValue = Defaults.defaultValue( int.class);
assertEquals(0, defaultValue.intValue());
}import com.google.common.base.*;

5. @Test
public void equalityAndIdentity()
{
//These could be useful for building equals methods
assertFalse(Equivalences.equals().equivalent( "you", null));
assertTrue(Equivalences.identity().equivalent( "hey", "hey"));
}import com.google.common.base.*;

6. @Test
public void joinSomeStrings()
{
ImmutableSet<String> strings = ImmutableSet.of( "A", "B", "C");
String joined = Joiner.on( ":").join(strings);
assertEquals( "A:B:C", joined);
}import com.google.common.base.*;

7. @Test
public void splitSomeStrings()
{
String string = "A:B:C";
String[] parts = string.split( ":"); //the old way
String backTogether = Joiner.on( ":").join(parts);
assertEquals(string, backTogether);
String gorbleString = ": A::: B : C :::";
Iterable<String> gorbleParts = Splitter.on( ":")
.omitEmptyStrings().trimResults().split(gorbleString);
String gorbleBackTogether = Joiner.on( ":").join(gorbleParts);
assertEquals(string, gorbleBackTogether); // A:B:C
}import com.google.common.base.*;

8. @Test
public void moreFunWithStrings()
{
assertNull(Strings.emptyToNull( ""));
assertEquals( "", Strings.nullToEmpty( null));
// About the only thing we ever used in commons-lang? :)
assertTrue(Strings.isNullOrEmpty( ""));
assertEquals( "oioioi", Strings.repeat("oi", 3));
assertEquals( "Too short ", Strings.padEnd("Too short", 15, ' '));
}import com.google.common.base.*;

9. //Some customers
Customer bob = new Customer(1, "Bob");
Customer lisa = new Customer(2, "Lisa");
Customer stephen = new Customer(3, "Stephen");
Customer ken = new Customer(null,"Ken");

10. @Test
public void toStringsAndHashcodes()
{
Object[] bobAndLisa = new Object[] { bob, lisa };
// Make some hashcode!
int hashCode = Objects.hashCode( bob, lisa);
assertEquals(Arrays.hashCode(bobAndLisa), hashCode);
// Build toString method
String string = Objects.toStringHelper( bob)
.add("name", bob.getName())
.add( "id", bob.getId()).toString();
assertEquals( "Customer{name=Bob, id=1}" , string);
}import com.google.common.base.*;

11. @Test(expected = NullPointerException. class)
public void needAnIntegerWhichIsNeverNull()
{
Integer defaultId = null;
Integer kensId = ken.getId() != null ? ken.getId() : defaultId;
// this one does not throw!
int kensId2 = Objects.firstNonNull( ken.getId(), defaultId);
assertEquals(0, kensId2);
// But the above does!
}import com.google.common.base.*;

12. @Test(expected = IllegalArgumentException. class)
public void somePreconditions()
{
// Pretend this is a constructor:
Preconditions.checkNotNull( lisa.getId()); // Will throw NPE
Preconditions.checkState(! lisa.isSick()); // Will throw ILE
Preconditions.checkArgument( lisa.getAddress() != null,
"No description for customer with id %s" ,lisa.getId());
}import com.google.common.base.*;

13. @Test
public void fancierFunctions()
{
Function<Customer, Boolean> isCustomerWithOddId
= new Function<Customer, Boolean>()
{
public Boolean apply(Customer customer)
{
return customer.getId().intValue() % 2 != 0;
}
};
assertTrue(isCustomerWithOddId.apply( bob));
assertFalse(isCustomerWithOddId.apply( lisa));
// Functions are great for higher-order functions, like
// project/transform, and fold
}import com.google.common.base.*;

14. @Test
public void somePredicates()
{
ImmutableSet<Customer> customers =
ImmutableSet.of(bob, lisa, stephen);
Predicate<Customer> itsBob = Predicates.equalTo( bob);
Predicate<Customer> itsLisa = Predicates.equalTo( lisa);
Predicate<Customer> bobOrLisa = Predicates.or(itsBob, itsLisa);
// Predicates are great to pass in to higher-order functions
// like filter/search
Iterable<Customer> filtered = Iterables.filter(customers, bobOrLisa);
assertEquals(2, ImmutableSet.copyOf(filtered).size());
}import com.google.common.base.*;

15. @Test
public void someSuppliers()
{
//Imagine we have Supploer that produces ingredients
IngredientsFactory ingredientsFactory = new IngredientsFactory();

//A function 'bake' - (see next slide)
bake();

//Then it's pretty easy to get a Factory that bakes cakes :)
Supplier<Cake> cakeFactory =
Suppliers.compose(bake(), ingredientsFactory);
cakeFactory.get();
cakeFactory.get();
cakeFactory.get();

assertEquals(3, ingredientsFactory.getNumberOfIngredientsUsed());
}import com.google.common.base.*;

16. private Function<Ingredients, Cake> bake() {
return new Function<Ingredients, Cake>() {
public Cake apply(Ingredients ingredients) {
return new Cake(ingredients);
}
};
}import com.google.common.base.*;

17. @Test
public void someThrowables()
{
try
{
try{
Integer.parseInt( "abc");
}
catch(RuntimeException e){
if(e instanceof ClassCastException) throw e; //old-style
Throwables.propagateIfInstanceOf(e, NumberFormatException. class); //the same
Throwables.propagateIfPossible(e); // Propagates if it is Error or RuntimeException
try {
Throwables.throwCause(e, true);
} catch (Exception e1) {
Throwables.propagate(e1); //Wraps if its a checked exception,
//or lets it flow if not
}
}
}
catch(RuntimeException e){
Throwables.getCausalChain(e);
Throwables.getRootCause(e);
Throwables.getStackTraceAsString(e);
}
import com.google.common.base.*;

18. @Test
public void someEnums()
{
assertEquals( "UNDER_DOG",
CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE,
"underDog"));

//Controlling services
Service service = new FunkyService();
service.start();
assertEquals(Service.State. RUNNING, service.state());
service.stop();
}import com.google.common.base.*;

19. @Test
public void someSets()
{
ImmutableSet<Customer> customers1 =
ImmutableSet.of(bob, lisa, stephen);
ImmutableSet<Customer> customers2 =
ImmutableSet.of(stephen, ken);

assertEquals(4, Sets.union(customers1, customers2).size());

assertEquals(ImmutableSet.of( stephen),
Sets.intersection(customers1, customers2));
}import com.google.common.collect.*;

20. @Test(expected=NullPointerException. class)
public void someConstraints()
{
//instead of new HashSet<Customer>()
HashSet<Customer> customers = Sets.newHashSet();
customers.add( null); //this works. But should it?

Set<Customer> noMoreNulls =
Constraints.constrainedSet(customers, Constraints.notNull());
noMoreNulls.add( null); //boom!
}import com.google.common.collect.*;

21. @Test
public void messAroundWithFile()
{
File file = new File("woop.txt");
try {
Files.touch(file);

Files.write( "Hey sailor!", file, Charsets.UTF_8);

//Breakpoint here.. have a look at the file..

Files.toByteArray(file);
Files.newInputStreamSupplier(file);
assertEquals( "Hey sailor!", Files.readFirstLine(file, Charsets. UTF_8));
assertEquals( "Hey sailor!", Files.toString(file, Charsets. UTF_8));

Files.deleteRecursively(file);

} catch (IOException e) {
Throwables.propagate(e);
}
}import com.google.common.io.*;

22. @Test
public void closingAndFlushing()
{
InputStream inputStream = System. in;
try {
inputStream.close(); //The old way
} catch (IOException e) {
Throwables.propagate(e);
}
Closeables.closeQuietly(inputStream ); //The new way

//Or flush:
PrintStream outputStream = System. out;
Flushables.flushQuietly(outputStream);
}import com.google.common.io.*;

23. @Test
public void classPathResources()
{
//This:
Resources.getResource( "com/tfnico/examples/guava/BaseTest.class" );

//instead of this:
String location = "com/tfnico/examples/guava/BaseTest.class" ;
URL resource2 =
this.getClass().getClassLoader().getResource(location);
Preconditions.checkArgument(resource2!= null,
"resource %s not found" , location);
}import com.google.common.io.*;

24. @Test
public void iNetAddressIsFixed()
{
try {

/**
* Unlike InetAddress.getByName(),
* the methods of this class never cause DNS services to be accessed.
* For this reason, you should prefer these methods as much as possible
* over their JDK equivalents whenever you are expecting to handle only
* IP address string literals -- there is no blocking DNS penalty for
* a malformed string.
*/
InetAddresses.forString( "0.0.0.0");

//Instead of this...
InetAddress.getByName( "0.0.0.0");

} catch (UnknownHostException e) {
Throwables.propagate(e);
}
}import com.google.common.net.InetAddresses;

25. TODO
•
Show off primitives
•
Show off CharMatcher
•
Add more collection examples
•
Add more higher order functions
•
Do concurrency stuff
•
Do cooler io stuff
•
Find patterns of old code that can be replaced
(For this presentation)

26. When to think Guava?
•For loops
•Temporary collections
•Mutable collections
•if( x == null)
•In short: method complexity

27. Arright, let’s try!