带你快速看完9.8分神作《Effective Java》—— Lambda 和 Stream篇（小王工作里用的很多）

Collections.sort(words, new Comparator<String>() {
  public int compare(String s1, String s2) {
    return Integer.compare(s1.length(), s2.length());
  }
});

Collections.sort(words, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Collections.sort(words, comparingInt(String::length));

words.sort(comparingInt(String::length));

public enum Operation {
    PLUS("+") {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        public double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        public double apply(double x, double y) {
            return x / y;
        }
    };
    private final String symbol;
    Operation(String symbol) {
        this.symbol = symbol;
    }
    @Override
    public String toString() {
        return symbol;
    }
    public abstract double apply(double x, double y);
}

public enum Operation {
    PLUS("+", (x, y) -> x + y),
    MINUS("-", (x, y) -> x - y),
    TIMES("*", (x, y) -> x * y),
    DIVIDE("/", (x, y) -> x / y);
    private final String symbol;
    private final DoubleBinaryOperator op;
    Operation(String symbol, DoubleBinaryOperator op) {
        this.symbol = symbol;
        this.op = op;
    }
    @Override
    public String toString() {
        return symbol;
    }
    public double apply(double x, double y) {
        return op.applyAsDouble(x, y);
    }
}

map.merge(key, 1, (count, incr) -> count + incr);

map.merge(key, 1, Integer::sum);

service.execute(GoshThisClassNameIsHumongous::action);

service.execute(() -> action());

x -> x

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
  return size() > 100;
}

@FunctionalInterface
interface EldestEntryRemovalFunction<K,V>{
  boolean remove(Map<K,V> map, Map.Entry<K,V> eldest);
}

public class Anagrams {
    public static void main(String[] args) throws IOException {
        File dictionary = new File(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);
        Map<String, Set<String>> groups = new HashMap<>();
        try (Scanner s = new Scanner(dictionary)) {
            while (s.hasNext()) {
                String word = s.next();
                groups.computeIfAbsent(alphabetize(word),
                        (unused) -> new TreeSet<>()).add(word);
            }
        }
        for (Set<String> group : groups.values())
            if (group.size() >= minGroupSize)
                System.out.println(group.size() + ": " + group);
    }
    private static String alphabetize(String s) {
        char[] a = s.toCharArray();
        Arrays.sort(a);
        return new String(a);
    }
}

hashmap.computeIfAbsent(K key, Function remappingFunction)

public class Anagrams {
public static void main(String[] args) throws IOException {
  Path dictionary = Paths.get(args[0]);
  int minGroupSize = Integer.parseInt(args[1]);
  try (Stream<String> words = Files.lines(dictionary)) {
    words.collect(
        groupingBy(word -> word.chars().sorted()
          .collect(StringBuilder::new,
          (sb, c) -> sb.append((char) c),
          StringBuilder::append).toString()))
      .values().stream()
      .filter(group -> group.size() >= minGroupSize)
      .map(group -> group.size() + ": " + group)
      .forEach(System.out::println);
    }
  }
}

public class Anagrams {
    public static void main(String[] args) throws IOException {
        Path dictionary = Paths.get(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);
        try (Stream<String> words = Files.lines(dictionary)) {
            words.collect(groupingBy(word -> alphabetize(word)))
                    .values().stream()
                    .filter(group -> group.size() >= minGroupSize)
                    .forEach(g -> System.out.println(g.size() + ": " + g));
        }
    }
    // alphabetize method is the same as in original version
    private static String alphabetize(String s) {
        char[] a = s.toCharArray();
        Arrays.sort(a);
        return new String(a);
    }
}

values().stream()

"Hello world!".chars().forEach(System.out::print);

"Hello world!".chars().forEach(x -> System.out.print((char) x));

private static List<Card> newDeck() {
  List<Card> result = new ArrayList<>();
  for (Suit suit : Suit.values())
    for (Rank rank : Rank.values())
      result.add(new Card(suit, rank));
  return result;
}

private static List<Card> newDeck() {
  return Stream.of(Suit.values())
    .flatMap(suit ->
      Stream.of(Rank.values())
        .map(rank -> new Card(suit, rank)))
    .collect(toList());
}