Clean Code with Google Guava

StringBuilder sb = new StringBuilder();
for (Iterator i = debtors.iterator(); i.hasNext();) {
  if (sb.length() != 0) {
    sb.append(", ");
  }
  sb.append(i.next());
}
out.println("Debtors: " + sb.toString());

out.println("Debtors: " + String.join(", ", debtors));

Very basic utilities

class Person implements Comparable {
  private String lastName;
  private String middleName;
  private String firstName;
  private int zipCode;
  // constructor, getters and setters are omitted
  @Override
  public int compareTo(Person other) {
    int cmp = lastName.compareTo(other.lastName);
    if (cmp != 0) {
      return cmp;
    }
    cmp = middleName.compareTo(other.middleName);
    if (cmp != 0) {
      return cmp;
    }
    cmp = firstName.compareTo(other.firstName);
    if (cmp != 0) {
      return cmp;
    }
    return Integer.compare(zipCode, other.zipCode);
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    Person other = (Person) obj;
    if (firstName == null) {
      if (other.firstName != null)
        return false;
    } else if (!firstName.equals(other.firstName))
      return false;
    if (lastName == null) {
      if (other.lastName != null)
        return false;
    } else if (!lastName.equals(other.lastName))
      return false;
    if (middleName == null) {
      if (other.middleName != null)
        return false;
    } else if (!middleName.equals(other.middleName))
      return false;
    if (zipCode != other.zipCode)
      return false;
    return true;
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
    result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
    result = prime * result + ((middleName == null) ? 0 : middleName.hashCode());
    result = prime * result + zipCode;
    return result;
  }
  @Override
  public String toString() {
    return "Person [lastName=" + lastName + ", middleName=" + middleName
        + ", firstName=" + firstName + ", zipCode=" + zipCode + "]";
  }
}

class Person implements Comparable {
  private String lastName;
  private String middleName;
  private String firstName;
  private int zipCode;
  // constructor, getters and setters are omitted
  @Override
  public int compareTo(Person other) {
    return ComparisonChain.start()
        .compare(lastName, other.lastName)
        .compare(firstName, other.firstName)
        .compare(middleName, other.middleName, Ordering.natural().nullsLast())
        .compare(zipCode, other.zipCode)
        .result();
  }
  @Override
  public boolean equals(Object obj) {
    if (obj == null || getClass() != obj.getClass()) {
      return false;
    }
    Person other = (Person) obj;
    return Objects.equals(lastName, other.lastName)
        && Objects.equals(middleName, other.middleName)
        && Objects.equals(firstName, other.firstName)
        && zipCode == other.zipCode;
  }
  @Override
  public int hashCode() {
    return Objects.hash(lastName, middleName, firstName, zipCode);
  }
  @Override
  public String toString() {
    return MoreObjects.toStringHelper(this)
        .omitNullValues()
        .add("lastName", lastName)
        .add("middleName", middleName)
        .add("firstName", firstName)
        .add("zipCode", zipCode)
        .toString();
  }
}

New Collections

Map counts = new HashMap<>();
for (String word : words) {
  Integer count = counts.get(word);
  if (count == null) {
    counts.put(word, 1);
  } else {
    counts.put(word, count + 1);
  }
}

List values = map.get(key);
if (values == null) {
  values = new ArrayList<>();
  map.put(key, values);
}
values.add(value);

Multiset counts = HashMultiset.create();
for (String word : words) {
  counts.add(word);
}

map.put(key, value);

public static final ImmutableSet COLOR_NAMES = ImmutableSet.of(
  "red",
  "green",
  "blue");
class Foo {
  final ImmutableSet bars;
  Foo(Set bars) {
    this.bars = ImmutableSet.copyOf(bars); // defensive copy!
  }
}

Predicate nonDefault = not(equalTo(DEFAULT_VALUE));
Iterable strings1 = transform(filter(iterable, nonDefault), toStringFunction());
Iterable strings2 = from(iterable).filter(nonDefault).transform(toStringFunction());

// Read the lines of a UTF-8 text file
ImmutableList lines = Files.asCharSource(file, Charsets.UTF_8).readLines();
// Count distinct word occurrences in a file
Multiset wordOccurrences = HashMultiset.create(
  Splitter.on(CharMatcher.WHITESPACE)
    .trimResults()
    .omitEmptyStrings()
    .split(Files.asCharSource(file, Charsets.UTF_8).read()));
// SHA-1 a file
HashCode hash = Files.asByteSource(file).hash(Hashing.sha1());
// Copy the data from a URL to a file
Resources.asByteSource(url).copyTo(Files.asByteSink(file));

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

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

Foo foo = Reflection.newProxy(Foo.class, invocationHandler)

Foo foo = (Foo) Proxy.newProxyInstance(
    Foo.class.getClassLoader(),
    new Class[] {Foo.class},
    invocationHandler);