Java8 Stream 的最佳实践

java8stream提供了对于集合类的流失处理，其具有以下特点：

Lazy Evaluation（长度可以无限）

只能使用一次

内部迭代

Lazy Evaluation类似函数式中的LazyList,只有在需要时才去求值。减少了内存消耗，Java中可以用Iterator模拟。只有在进行终端操作时，stream才会执行。但是这个延迟计算不能保证流中的某个值单独延迟，需要时单独分配资源。

内部迭代的意思是我们告诉程序要实现的功能，迭代由程序自己控制。如filter时，我们只提供Predicate，而不是自己写for循环，至于程序自己是如何实现过滤数据的，我们并不关心。可能随着stream类库的迭代，实现效率会逐步提升。PS：新版本的Java类库String终于可以直接拼串了，而且性能很好。

使用Stream的原则：

可读性、bugfree、短

Do

开发过程中最常用的Stream实现就是filter map reduce/collect操作，这种处理可以替代很大部分的（至少50%）的for循环。

// 读入数据，笔试用

Scanner sc = new Scanner(System.in);

String ss = sc.nextLine();

int[] nums = Arrays.stream(ss.split("\\s")).mapToInt(Integer::valueOf).toArray();

// flatMap只使用一次

// 这个例子来自于On Java 8

// 字符串打散，注意不要打散成char

// 常见的模式（方法返回流）

public static Stream<String> stream(String filePath) throws Exception {

    return Files.lines(Paths.get(filePath))

    .skip(1) // First (comment) line

    .flatMap(line ->

    Pattern.compile("\\W+").splitAsStream(line));

}

// 一对多关系，保存到数据库,命令式编程需要两层for循环

List<Role> roles = users.stream().flatMap(user -> user.getRoles().stream()).collect(toList());

saveBatch(roles);

// 生成随机数组

int[] nums = new Random().ints(0, 100).limit(10).toArray();

// optional流的处理

stream1.filter(Optional::isPresent).map(Optional::get).collect(toList());

stream2.map(opt -> opt.orElse(defaultValue)).collect(toList());

// forEach

stream3.forEach(System.out::println);

// 生成Map,这种最终操作我后面会发文章详细分析Collectors工具类

Map<Long, User> idToUserMap = users.stream().collect(toMap(User::getId, it -> it));

// 获取角色到用户的映射(一对多）

HashMultiMap<Long, User> roleIdToUsersMap = userVos.stream().collect(toMultiMap(UserVo::getRoleId, UserVo::getUser, HashMultimap::create));

// 分组

Map<Integer, List<User>> usersByLevelMap = users.collect(groupingBy(User::getLevel));

// 字符串拼接

subscriptions.stream().map(Object::toString).collect(joining(",", "(", ")"));

// 参数校验

boolean validated = request.getResources().stream().allMatch(authorities::contains);

if (!validated) throw ...

IntStream::sum, max, min, average, count...

// 教学意义

质数流，完全数流...

开发中的大部分时候我们不需要特别在意性能，仅在需要时优化。

比如你需要一个字符串匹配算法，需要自己实现一些特殊功能，先写出暴力匹配，之后再优化。

比如我想获取一个前十名的排行榜，我不必在自己编写优先队列，或者使用其他类库。当需要优化时，再考虑优化。

// 至少我们可以确定：使用stream的内部迭代中时间复杂度最多是nlogn。

Comparator<User> compScore = Comparator.comparingDouble(User::getScore).reversed();

List<User> top10 = users.stream().sorted(compScore).limit(10).collect(toList());

Don’t

毕竟Java不是纯函数式的语言，还要前向兼容，所以只能部分利用函数式的思想。以下这些做法在开发中应该避免。

忽略空指针。对于可能存在空指针的类直接使用Stream，特别是类中具有复杂的引用关系时，比如我通过Feign获取的对象。即使使用Optional，也会令可读性大大下降。
包含复杂的异常处理。异常处理时不要使用stream，stream天生和异常相冲突，函数式编程中异常也是一类副作用，两种很难相容。Java也没有Either类。尽量少用，非要用可以使用Optional或者 try-catch 包装，
使用stream类中的flatMap实现多重循环。这样可读性很差。就想try-catch嵌套一样难受。英文里叫boilerplate，不知道中文用哪个词，大意就是跟八股文一样繁杂。
使用forEach。尽量不要使用forEach，forEach只限定在几种特定的编程模式。这个方法很难调试。
在代码面试或笔试中使用。因为人家面试官考的就是你对命令式编程的理解、算法与数据结构、函数内部状态的追踪，而且代码笔试中特别看重性能，stream会生成很多不可变的中间变量，占用空间，在在线编程环境上性能不稳定。
使用parallel方法。这个方法对于性能的提升有限，只有在进行大量计算时有用。几乎用不到。