使用 Stream API 简化代码

public Map<Long, List<Character>> groupCharacterByGamer() {
    List<Character> characters = characterDao.getCharacters();
    Map<Long, List<Character>> results = new HashMap<>();
    for (Character character : characters) {
        if (character.getLevel() > 60) {
            List<Character> gamerCharacters = results.get(character.getGamerId());
            if (gamerCharacters == null) {
                gamerCharacters = new ArrayList<>();
            }
            gamerCharacters.add(character);
            results.put(character.getGamerId(), gamerCharacters);
        }
    }
    return results;
}

@Data
static class Gamer {
    private Long id;
    private String name;
}

@Data
static class Character {
    private Long id;
    private Long gamerId;
    private String name;
    private Integer level;
}

public interface CharacterDao {
    List<Character> getCharacters();
}

public Map<Long, List<Character>> groupCharacterByGamerWithStreamAPI() {
    List<Character> characters = characterDao.getCharacters();
    return characters
            .stream()
            .filter(character -> character.getLevel() > 60)
            .collect(Collectors.groupingBy(Character::getGamerId));
}

new Predicate<Character>() {
    @Override
    public boolean test(Character character) {
        return character.getLevel() > 60;
    }
}

Runnable r = () -> System.out.print("Lambda");
executor.submit(r);

executor.submit(() -> System.out.print("Lambda"));

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

List.of("a","b","c").forEach(s -> System.out.println(s));
// 等价于
List.of("a","b","c").forEach(System.out::println);

public Map<Long, List<Character>> groupCharacterByGamerWithStreamAPI() {
    return characterDao
            .getCharacters()
            .stream() // 获取流数据源
            .filter(c -> c.getLevel() > 60) // 中间操作
            .collect(Collectors.groupingBy(Character::getGamerId)); // 终点操作
}

// 生成5个随机数
Stream.generate(Math::random).limit(5).forEach(System.out::println);


// 跳过第一行的表头
Files.lines(Paths.get("test.csv")).skip(1).forEach(System.out::println);

// 统计非空字符串数量
long count = Stream.of("a", "b", "", "c").filter(s -> !s.isEmpty()).count();

public static <T> Predicate<T> as(Predicate<T> predicate) {
    return predicate;
}

long count = Stream.of("a", "b", "", "c").filter(as(String::isEmpty).negate()).count();

// 将字符转换成 ASCII 码
Stream.of('a', 'b', 'c').map(Object::hashCode).forEach(System.out::println);

/**
* 从文件中按行读取字符串，并将字符串逐行转换成实体对象
*
* @param path 文件路径
* @return 转换后的实体类列表
* @throws IOException 打开文件过程中的IO异常
*/
public List<Entity> parseToEntityList(Path path) throws IOException {

    try (Stream<String> stream = Files.lines(path)) {
        return stream.filter(as(String::isEmpty).negate())
                .map(Entity::valueOf) // 省略 Entity 类定义 和 valueOf 方法
                .collect(Collectors.toList());
    }
}

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

 // 将多个List 合并成一个 List
List<Integer> numbers =
        Stream.of(List.of(1, 2), List.of(1, 2, 3), List.of(1, 2, 3, 4))
                .flatMap(l -> l.stream()) // 可以替换成更简洁的方法引用形式 flatMap(List::stream)
                .collect(Collectors.toList());
System.out.println(numbers); // [1, 2, 1, 2, 3, 1, 2, 3, 4]

Function<List<Integer>, Stream<Integer>> mapper = List::stream;
List<Integer> numbers =
        Stream.of(List.of(1, 2), List.of(1, 2, 3), List.of(1, 2, 3, 4))
                .flatMap(mapper)
                .collect(Collectors.toList());
System.out.println(numbers); // [1, 2, 1, 2, 3, 1, 2, 3, 4]

// 获取系统变量，并按key的长度排序
System.getenv()
        .keySet()
        .stream()
        .sorted((x, y) -> x.length() - y.length()) // 还可简写为 .sorted(Comparator.comparingInt(String::length))
        .forEach(System.out::println);

Optional<String> result =
        Stream.of("one", "two", "three", "four")
                .peek(s -> System.out.println("Iterated value: " + s))
                .findFirst();
System.out.println(result.orElse("Not found"));

public interface CharacterDao {
    @Nullable
    List<Character> getCharacters();

    @Nullable
    Character findOne(Long id);
}

public Map<Long, List<Character>> groupCharacterByGamerWithStreamAPI() {
    List<Character> characters = characterDao.getCharacters();
    // 判空
    if (characters == null) {
        characters = Collections.emptyList();
    }
    return characters
            .stream()
            .filter(character -> character.getLevel() > 60)
            .collect(Collectors.groupingBy(Character::getGamerId));
}

public Map<Long, List<Character>> groupCharacterByGamerWithStreamAPI() {
    List<Character> characters = characterDao.getCharacters();
    return Optional.ofNullable(characters)
            .orElse(Collections.emptyList())
            .stream()
            .filter(character -> character.getLevel() > 60)
            .collect(Collectors.groupingBy(Character::getGamerId));
}

public Character findCharacterById(Long id) {
    return Optional.ofNullable(characterDao.findOne(id))
            .orElseThrow(() -> new IllegalArgumentException(id + " not exists"));
}

// 求和
int sum = IntStream.range(1,5).reduce(0, (a,b) -> a + b);
// 字符串拼接
String contact = Stream.of("a","b","c").reduce("", String::concat);
// 字符串拼接，无种子，返回值为Optional，注意与上面的区别
contact = Stream.of("a","b","c").reduce(String::concat).get();

// 求字符串长度平均值
Double avg = Stream.of("abc", "bc", "c").collect(Collectors.averagingInt(String::length));

// 按等级是否大于60分区
public Map<Boolean, List<Character>> pationCharacterByLevel60() {
    List<Character> characters = characterDao.getCharacters();
    return Optional.ofNullable(characters)
            .orElse(Collections.emptyList())
            .stream()
            .collect(Collectors.partitioningBy(character -> character.getLevel() > 60));
}