public interface Comparator<T> { 
    int compare(T obj1, T obj2); 
}

// Java 7 
Collections.sort(peoples, new Comparator<Person>() {

    @Override
    public int compare(Person p1, Person p2) {

        return p1.name.compareTo(p2.name);
    }
});

@FunctionalInterface 
public interface FooBarQuery { 
    public abstract Foo findAllFoos(Bar bar); 
}

//    avoid 
public class Foo<T> {

    public Foo<R> apply(Function<T, R> fn);

    public Foo<T> apply(UnaryOperator<T> fn); 

}

//    prefer
public class Foo<T> {

    public Foo<R> applyFunction(Function<T, R> fn);

    public Foo<T> applyOperator(UnaryOperator<T> fn); 

}

// 编译不通过
public Function<String, Class> loader() { 
    return className -> Class.forName(className); 
}

public Function<String, Class> loader() { 
    return Unchecked.function(Class::forName);
}

String a = "AB";
String b = null;

Optional<String> a = Optional.of("AB");
Optional<String> b = Optional.empty();
Optional<String> c = null; // NO NO NO

// 当某个库、API 没找到会返回 NULL
public Foo findFoo(String key) { … }

// 程序中必须记住要对那些可能为 NULL 的变量做检查
Foo foo = findFoo(key); 
if (foo == null) { 
    foo = Foo.DEFAULT;  // 或者抛出一个异常
}

//    prefer 
Foo foo = findFoo(key).orElse(Foo.DEFAULT);

//    avoid ifPresent() 
Optional<Foo> optFoo = findFoo(key); 
if (optFoo.ifPresent()) { … }

//而不是 return user.isPresent() ? user.get() : null;
return user.orElse(null);  
return user.orElse(UNKNOWN_USER);

return user.orElseGet(() -> fetchAUserFromDatabase());
//而不要 return user.isPresent() ? user: fetchAUserFromDatabase();

user.ifPresent(System.out::println);
//而不要下边那样
if (user.isPresent()) {
  System.out.println(user.get());
}

return user.map(u -> u.getOrders()).orElse(Collections.emptyList())

// 上面避免了我们类似 Java 8 之前的做法
if(user.isPresent()) {
    return user.get().getOrders();
} else {
    return Collections.emptyList();
}

return user.map(u -> u.getUsername())
           .map(name -> name.toUpperCase())
           .orElse(null);

List<Trade> trades = loadTrades(); 
List<Money> valued = new ArrayList<Money>(); 
for (Trade t : trades) {
    if (t.isActive()) {
       Money pv = presentValue(t);
       valued.add(pv);
    }
}

List<Trade> trades = loadTrades(); 

List<Money> valued = 
  trades.stream()
        .filter(t -> t.isActive())
        .map(t -> presentValue(t))
        .collect(Collectors.toList());

//   avoid
strings.stream().filter(s -> s.length() > 2).sorted()
	.map(s -> s.substring(0, 2)).collect(Collectors.toList());

//   prefer
strings.stream()
	.filter(s -> s.length() > 2)
	.sorted()
	.map(s -> s.substring(0, 2))
	.collect(Collectors.toList());

//   avoid
strings.stream()
	.sorted(Comparator.reverseOrder())
	.limit(10)
	.collect(Collectors.toMap(Function.identity(), String::length));

//   prefer
strings.stream()
	.sorted(reverseOrder())
	.limit(10)
	.collect(toMap(identity(), String::length));

//   avoid
strings.stream()
	.map(s -> s.length())
	.collect(toList());

Stream<Object> objects = Stream.of(
	"a string",
	42,
	new String[] { "an array" },
	"another string");

// 转换 Entity 为 Map
Map<Integer, Entity> entityById = entities.stream()
	.collect(toMap(Entity::getId, identity()));

// 经常使用的情况
Map<Integer, Entity> entityById = entities.stream()
	.collect(ExtraCollectors.toByIdMap());

private static class ExtraCollectors {
  public static Collector<Entity,?,Map<Integer,Entity>> toByIdMap() {
	return Collectors.toMap(Entity::getId, identity());
  }
}

List<Trade> trades = loadTrades(); 
Predicate<Trade> activePredicate = t -> t.isActive(); 
Function<Trade, Money> valueFn = t -> presentValue(t); 

List<Money> valued = 
  trades.stream()
        .filter(activePredicate)
        .map(valueFn)
        .collect(Collectors.toList());

// prefer 
LocalDate date = LocalDate.of(2018, 05, 10);

// avoid 
Temporal date = LocalDate.of(2018, 05, 10);