从迭代到流的操作

  1. List<String> words; // words列表中保存某本书中所有单词
  3. // 1. 传统方式迭代
  4. int count = 0;
  5. for(String w : words) {
  6.     if(w.length() > 12){
  7.         count++;
  8.     }
  9. }
  11. // 2. 使用流
  12. long count = words.stream()
  13.     .filter(w -> w.length() > 12)
  14.     .count();

流的创建

  • 流创建了只能被操作一次，重新使用会抛出异常 ```java // 初始化数组 String[] strArr = {“hello”, “world”, “test”, “compute”, “red”}; // 将数组转换为 stream 流 Stream words1 = Stream.of(strArr); Stream words11 = Arrays.stream(strArr); // 将静态数组转换为 stream 流 Stream words2 = Stream.of(“aaa”, “bbb”, “ccc”); // 创建一个不包含任何元素的流 Stream silence = Stream.empty();

Path path = Paths.get(“E:/t1.txt”); String contents = new String(Files.readAllBytes(path), StandardCharsets.UTF_8); Stream wordAnotherWay = Pattern.compile(“\PL+”).splitAsStream(contents); wordAnotherWay.forEach(System.out::println);

/ ———————————————无限流——————————————— / // 获取一个常量值的流 Stream echos = Stream.generate(() -> “Echo”); // 获取一个随机数的流 Stream randoms = Stream.generate(Math::random); // 获取一个指定规则的序列流 Stream integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

  2. <a name="cnMZC"></a>
  3. # 中间操作
  4. ```java
  5. // 初始化一个字符串流
  6. Stream<String> strStream = Stream.of("hello", "world", "test", "compute", "red", "hello");
  7. // 过滤得到字符串长度大于4的字符串
  8. Stream<String> words1 = strStream.filter(w -> w.length() > 4);
  9. // 将流中的所有字符串元素转为大写
  10. Stream<String> words2 = strStream.map(String::toUpperCase);
  11. // 将流中的字符串元素转为每个字母组成的流，然后将其打平
  12. Stream<String> words3 = strStream.flatMap(s -> Stream.of(s.split("")));
  13. // 从开头保留3个元素
  14. Stream<String> words4 = strStream.limit(3);
  15. // 从开头舍弃3个元素
  16. Stream<String> words5 = strStream.skip(3);
  17. // 对流进行升序或降序操作
  18. Stream<String> words6 = strStream.sorted();
  19. Stream<String> words7 = strStream.sorted(Comparator.reverseOrder());
  20. // 去重
  21. Stream<String> words8 = strStream.distinct();
  22. // 将两个流进行连接
  23. Stream<String> words9 = Stream.concat(Stream.of("hello".split("")), Stream.of("world".split("")));

终结操作

约减

  1. // 初始化字符串数组
  2. String[] strArr = {"hello", "world", "test", "compute", "red", "hello"};
  4. // 获取流中的最大元素
  5. Optional<String> result1 = Stream.of(strArr).max(String::compareToIgnoreCase);
  6. // 获取流中的最小元素
  7. Optional<String> result2 = Stream.of(strArr).min(String::compareToIgnoreCase);
  8. // 获取流中的第一个元素
  9. Optional<String> result3 = Stream.of(strArr).findFirst();
  10. // 获取流中的任意一个元素
  11. Optional<String> result4 = Stream.of(strArr).parallel().findAny();
  13. // 流中是否存在 h 开头的元素
  14. boolean r1 = Stream.of(strArr).anyMatch(s -> s.startsWith("h"));
  15. // 流中是否全部元素都以 h 开头
  16. boolean r2 = Stream.of(strArr).allMatch(s -> s.startsWith("h"));
  17. // 流中是否没有以 s 开头的元素
  18. boolean r3 = Stream.of(strArr).noneMatch(s->s.startsWith("s"));

收集结果

Optional类型

创建optional值

  1. // 创建一个空Optional
  2. Optional.empty();
  3. // 创建一个具有value值的Optional，如果value为null，则抛出空指针异常
  4. Optional.of(T valuel);
  5. // 创建一个具有value值的Optional，如果value为null，则创建一个空的Optional
  6. Optional.ofNullable(T value);

获取Optional值

  1. // 创建一个Optional对象
  2. Optional<String> result = Optional.ofNullable(string);
  3. // 获取Optional对象中的值，如果Optional对象中不存在值，则括号内的值为默认值
  4. String str = result.orElse("");
  5. // 获取Optional对象中的值，如果Optional对象中不存在值，则执行括号内的匿名函数计算值
  6. String str2 = result.orElseGet(String::new);
  7. // 获取Optional对象中的值，如果Optional对象中不存在值，则抛出括号内的异常信息
  8. String str3 = result.orElseThrow(Exception::new);

消费Optional值

  1. // 初始化一个List
  2. List<String> list = new ArrayList<>(Arrays.asList("aa", "bb", "cc"));
  3. // 创建Optional对象
  4. Optional<String> result = Optional.ofNullable(string); // string 变量可能为null
  5. // 如果Optional不为空，则执行括号内的匿名函数，否则忽略
  6. result.ifPresent(list::add);
  7. // 如果Optional不为空，则执行括号内的匿名函数，否则调用emptyAction
  8. result.ifPresentOrElse(list::add, emptyAction); // emptyAction的类型为Runnable

管道化Optional值