guava.platypus

[pagewidth:29.7cm][pageheight:21.0cm]
[tmargin:1.27cm][bmargin:1.27cm][lmargin:1.27cm][rmargin:1.27cm]
[columns:3]
[ff:TIMES_ROMAN][fsize:14pt]Guava Reference Card[paraskip:0li]

[ff:TIMES_ROMAN][fsize:6]by Tom Denley -- licensed under a Creative Commons Attribution 3.0 Unported License.


[ff:TIMES_ROMAN][fsize:10pt][+b]Functional Units[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
interface Function<F,T>  T apply(F)          [+b]F[-b][]
interface Predicate<T>   boolean apply(T)    [+b]P[-b][]
interface Supplier<T>    T get()             [+b]S[-b][]

[+i]Functions[-i]   .identity()[]
            .constant(E)[]
            .forSupplier([+b]S[-b]<T>)[]
            .forMap(Map<F,T>)


[+i]Predicates[-i]  .alwaysTrue() / .alwaysFalse()[]
            .isNull() / .notNull()[]
            .equalTo(T)[]
            .instanceOf(Class<?>)[]
            .in(Collection<? extends T>)[]
            .not([+b]P[-b]<T>)[]
            .and([+b]P[-b]<T>,[+b]P[-b]<T>) / .or([+b]P[-b]<T>,[+b]P[-b]<T>)


[+i]Suppliers[-i]   .compose([+b]F[-b]<F,T>, [+b]S[-b]<F>)[]
            .memoize([+b]S[-b]<T>)


[ff:TIMES_ROMAN][fsize:10pt][+b]Functional Operations[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
[+i]Iter{able/ator}s[-i][]
  boolean .all(Iter<T>, [+b]P[-b]<T>)[]
  boolean .any(Iter<T>, [+b]P[-b]<T>)[]
  Iter<T> .concat(Iter<Iter<T>>)[]
  Iter<T> .filter(Iter<T>, [+b]P[-b]<T>)[]
  Iter<T> .transform(Iter<F>, [+b]F[-b]<F,T>)[]
  T       .getOnlyElement(Iter<T>, T default)[]
  T       .find(Iter<T>, [+b]P[-b]<T>, T default)


[+i]Collections2[-i][]
  Coll<E> .filter(Coll<E>, [+b]P[-b]<E>)[]
  Coll<T> .transform(Coll<F>, [+b]F[-b]<F,T>)


[+i]Lists[-i][]
  List<T>       .reverse(List<T>)[]
  List<List<T>> .partition(List<T>, int size)[]
  List<T>       .transform(List<F>, [+b]F[-b]<F,T>)


[ff:TIMES_ROMAN][fsize:10pt][+b]Iterable Builders[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
[+i]Immutable{Map/List/Collection/Set}[-i][]
  .of(...)[]
  .copyOf({Map/List/Collection/Set})[]
  .builder()


[+i]Iterators[-i][]
  Iterator<T>    .forArray(T...)[]
  Iterator<T>    .forEnumeration(Enumeration<T>)


[+i]Lists[-i][]
  ArrayList<T>   .newArrayList(T...)[]
  LinkedList<T>  .newLinkedList(T...)


[+i]Maps[-i][]
  HashMap<K,V>   .newHashMap()[]
  TreeMap<K,V>   .newTreeMap()[]
  Map<K,V>       .difference(Map<K,V>, Map<K,V>)[]
  Map<K,V>       .uniqueIndex(Iter<V>, [+b]F[-b]<V,K>)[]
  Map<Str,Str>   .fromProperties(Properties)


[+i]Sets[-i][]
  HashSet<E>     .newHashSet()[]
  TreeSet<E>     .newTreeSet()[]
  Set<Enum<E>>   .complementOf(Collection<Enum<E>>)[]
  Set<E>         .newSetFromMap(Map<E, Boolean>)[]
  Set<E>         .union(Set<E>, Set<E>)[]
  Set<E>         .intersection(Set<E>, Set<?>)[]
  Set<E>         .difference(Set<E>, Set<?>)[]
  Set<E>         .cartesianProduct(List<Set<E>>)


[+i]new MapMaker()[-i][]
  .concurrencyLevel(int)[]
  .weakKeys() / .weakValues()[]
  .makeComputingMap(F<K,V>)


[ff:TIMES_ROMAN][fsize:10pt][+b]MultiMaps[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
MultiMap<K,V>  ~=  Map<K, Collection<V>>


[+i]MultiMaps[-i][]
  MultiMap<K,V>  .index(Iterable<V>, [+b]F[-b]<V,K>)[]
  MultiMap<K,V>  .transformValues(MultiMap<K,X>,[]
                                  [+b]F[-b]<X,V>)


[ff:TIMES_ROMAN][fsize:10pt][+b]Caches[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
interface Cache<K,V>  V get(K)[]
                      V getUnchecked(K)[]
                      void invalidate(K)[]
                      void invalidateAll()[]
                      long size()[]
                      CacheStats stats()[]
                      Map<K,V> asMap()[]
                      void cleanUp()


[+i]CacheBuilder.newBuilder()[-i][]
  .concurrencyLevel(int)[]
  .weakKeys()[]
  .maximumSize(int)[]
  .expireAfterWrite(int, TimeUnit)[]
  .build(CacheLoader.from([+b]F[-b]<K,V>))[]
  .build(CacheLoader.from([+b]S[-b]<V>))


[ff:TIMES_ROMAN][fsize:10pt][+b]Utility[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
[+i]Preconditions[-i]   .checkArgument(boolean)[]
                .checkState(boolean)[]
                .checkNotNull(T)[]
                .checkElementIndex(int i, int size)


[+i]Objects[-i][]
   boolean      .equal(Object, Object)[]
   T            .firstNotNull(T, T)[]
   Helper       .toStringHelper(Class<?>)


[+i]Throwables[-i][]
   Throwable    .getRootCause(Throwable)[]
   String       .getStackTraceAsString(Throwable)


[+i]Strings[-i][]
   String       .nullToEmpty(String)[]
   String       .emptyToNull(String)[]
   boolean      .isNullOrEmpty(String)[]
   String       .padStart(String, int, char)[]
   String       .padEnd(String, int, char)[]
   String       .repeat(String, int)


[ff:TIMES_ROMAN][fsize:10pt][+b]Tokenisation[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
[+i]Joiner[-i]    .on(String)[]
          .skipNulls()[]
          .useForNull(String)[]
          .join(Iterable<?>)


[+i]Splitter[-i]  .on(String)[]
          .omitEmptyStrings()[]
          .trimResults()[]
          .limit(int)[]
          .split(String)


[ff:TIMES_ROMAN][fsize:10pt][+b]Ranges[-b][paraskip:0li]

[ff:COURIER][fsize:8pt]
class Range<C extends Comparable> {[]
  boolean  contains(C)[]
  boolean  containsAll(Iterable<C>)[]
  boolean  encloses(Range<C>)[]
  boolean  isConnected(Range<C>)[]
  Range<C> intersection(Range<C>)[]
  Range<C> span(Range<C>)[]
}


[+i]Ranges[-i][]
  Range<C> .open(C,C) / .closed(C,C)[]
  Range<C> .lessThan(C) / .greaterThan(C)[]
  Range<C> .atMost(C) / .atLeast(C)[]
  Range<C> .all()[]
  Range<C> .singleton(C)[]
  Range<C> .encloseAll(Iterable<C>)