// 原本是傳回集合
  public List<String> getData(){...};
  // 可以改成傳回Iterable (RECOMMAND)
  public Iterable<String> getData(){...};
  // 或改成傳回Iterator
  public Iterator<String> getData(){...};

assertThat(data, Matchers.<MyClass>iterableWithSize(1));

    package java.util;
     
    /**
     * @since 1.2
     */
    public interface Iterator<E> {
        boolean hasNext();
     
        E next();
     
        void remove();
    }

    /** Implementing this interface allows an object to be the target of
     *  the "foreach" statement.
     * @since 1.5
     */
    public interface Iterable<T> {
     
        Iterator<T> iterator();
    }

String myArray = new String[]{"foo", "bar", "baz"};
for(String each : myArray) { // this one works
 
}
 
doIterate(myArray); // this cause compiler level error
 
public doIterate(Iterable args) {
}

public interface Predicate<T> {
  /**
   * Returns the result of applying this predicate to {@code input}. This method is <i>generally
   * expected</i>, but not absolutely required, to have the following properties:
   *
   * <ul>
   * <li>Its execution does not cause any observable side effects.
   * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *     Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *     predicate.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@Nullable T input);
 
  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
   * {@link Predicate} that it considers <i>interchangeable</i> with this one. "Interchangeable"
   * <i>typically</i> means that {@code this.apply(t) == that.apply(t)} for all {@code t} of type
   * {@code T}). Note that a {@code false} result from this method does not imply that the
   * predicates are known <i>not</i> to be interchangeable.
   */
  @Override
  boolean equals(@Nullable Object object);
}

    class IsGreateThenZero implements Predicate<Integer> {
        @Override
        public boolean apply(Integer input) {
            return input > 0;
        }
    }

    class IsLessThenTen implements Predicate<Integer> {
        @Override
        public boolean apply(Integer input) {
            return input < 10;
        }
    }

IsGreateThenZeroAndLessThenTenPredicate = Predicates.and(new IsGreateThenZero(), new IsLessThenTen());

public interface Function<F, T> {
  /**
   * Returns the result of applying this function to {@code input}. This method is <i>generally
   * expected</i>, but not absolutely required, to have the following properties:
   *
   * <ul>
   * <li>Its execution does not cause any observable side effects.
   * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *     Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
   *     function.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this function does not accept null
   *     arguments
   */
  T apply(@Nullable F input);
 
  /**
   * Indicates whether another object is equal to this function.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
   * {@link Function} that it considers <i>interchangeable</i> with this one. "Interchangeable"
   * <i>typically</i> means that {@code Objects.equal(this.apply(f), that.apply(f))} is true for all
   * {@code f} of type {@code F}. Note that a {@code false} result from this method does not imply
   * that the functions are known <i>not</i> to be interchangeable.
   */
  @Override
  boolean equals(@Nullable Object object);
}

ImmutableMap.<String, Object>builder().put("a", objectA)..put("b", objectB).build();

find = Iterators.find(myCollection.iterator(), predicate);
find2 = Iterables.find(myCollection, predicate);
// find1 == find2

    List<String> list1 = Lists.newArrayList("1", "2", "3");
    List<Double> list2 = Lists.transform(list1, new Function<String, Double>() {
       public Double apply(String from) {
          return Double.parseDouble(from);
       }
    });
    System.out.println(Joiner.on(" | ").join(list2));
     
    // result
    // 1.0 | 2.0 | 3.0

    List<String> list = Lists.newArrayList("A100", "B100", null, "B200");
    Iterable<String> filtered = Iterables.filter(list, new Predicate<String>() {
       public boolean apply(String input) {
          return input == null || input.startsWith("B");
       }
    });
     
    System.out.println(Joiner.on("; ").useForNull("B000").join(filtered));
     
    // result
    // B100; B000; B200

 Ordering.from(lastNameComparator);

    import static com.google.common.base.Predicates.and;
    import static com.google.common.base.Predicates.compose;
    import static com.google.common.base.Predicates.in;
    import static com.google.common.base.Predicates.not;
     
    List<String> list1 = Lists.newArrayList("1", "2", "3");
    List<String> list2 = Lists.newArrayList("1", "4", "5");
    List<String> list3 = Lists.newArrayList("1", "4", "6");
     
    boolean result = and( not( in(list1) ), in(list2), in(list3)).apply("1");
     
    System.out.println(result);  // false
     
    List<String> list1 = Lists.newArrayList("A1", "A2", "A3");
    boolean result = compose(in(list1), new Function<String, String>() {
       public String apply(String from) {
          return "A" + from;
       }
    }).apply("1");
     
    System.out.println(result);  // true

    public class Person {
       private String firstName;
       private String lastName;
     
       public Person(String firstName, String lastName) {
          this.setFirstName(firstName);
          this.setLastName(lastName);
       }
     
       @Override
       public String toString() {
          return getFirstName() + " " + getLastName();
       }
     
       public void setFirstName(String firstName) {
          this.firstName = firstName;
       }
     
       public String getFirstName() {
          return firstName;
       }
     
       public void setLastName(String lastName) {
          this.lastName = lastName;
       }
     
       public String getLastName() {
          return lastName;
       }
    }

    List<Person> persons = Lists.newArrayList(
       new Person("Alfred", "Hitchcock"),
       null,
       new Person("Homer", "Simpson"),
       new Person("Peter", "Fox"),
       new Person("Bart", "Simpson"));
     
    Comparator<Person> lastNameComparator = new Comparator<Person>() {
       public int compare(Person p1, Person p2) {
          return p1.getLastName().compareTo(p2.getLastName());
       }
    };
     
    Comparator<Person> firstNameComparator = new Comparator<Person>() {
       public int compare(Person p1, Person p2) {
          return p1.getFirstName().compareTo(p2.getFirstName());
       }
    };
     
    // order by last name ascending
    Ordering<Person> ordering = Ordering.from(lastNameComparator);
    System.out.println(ordering.nullsLast().sortedCopy(persons));
     
    // order by last name descending, first name ascending
    ordering = ordering.reverse().compound(firstNameComparator);
    System.out.println(ordering.nullsLast().sortedCopy(persons));

import java.util.*;
import com.google.common.collect.*;
 
public class ListWithDefault<E> extends ForwardingList<E> {
    final E defaultValue;
    final List<E> delegate;
 
    ListWithDefault(List<E> delegate, E defaultValue) {
        this.delegate = delegate;
        this.defaultValue = defaultValue;
    }
    @Override protected List delegate() {
        return delegate;
    }
    @Override public E get(int index) {
        E v = super.get(index);
        return (v == null ? defaultValue : v);
    }
    @Override public Iterator<E> iterator() {
        final Iterator<E> iter = super.iterator();
        return new ForwardingIterator<E>() {
            @Override protected Iterator<E> delegate() {
                return iter;
            }
            @Override public E next() {
                E v = super.next();
                return (v == null ? defaultValue : v); 
            }
        };
    }
}
 
public static void main(String[] args) {
    List<String> names = new ListWithDefault<String>(
        Arrays.asList("Alice", null, "Bob", "Carol", null),
        "UNKNOWN"
    );
 
    for (String name : names) {
        System.out.println(name);
    }
    // Alice
    // UNKNOWN
    // Bob
    // Carol
    // UNKNOWN
 
    System.out.println(names);
    // [Alice, null, Bob, Carol, null]
}