首页JavaJava高阶

MOOC 个人学习笔记

# 1. 流的概述

a sequence of elements from source that supports aggregate operations

  • sequence of elements: 一个流对外提供一个接口，可以访问到一串特定的数据。流不存储元素，但是可以根据需要进行计算转化
  • source：数据来源，如数据结构，数组，文件等
  • aggregate operation：聚合操作，流支持像 SQL 操作或者其他函数式语言的操作，如 filter/map/reduce/find/match/sorted 等
  • pipelining: 很多流操作也是返回一个流
  • Internal Iteration: 流操作进行迭代，用户感知不到循环遍历

# Stream 语法

  • 类似 SQL 语句，遵循 “做什么而非怎么做” 原则

# 流的工作流程

  • 流的创建
  • 流的转换，将流转换为其他流的中间操作，可包括多个步骤 (惰性操作)
  • 流的计算结果。这个操作会强制执行之前的惰性操作。这个步骤以后，流就再也不用了

# 2. 流的创建

  • Collection 接口的 stream 方法
    Stream<String> a1 = new ArrayList<String>().stream();
    Stream<String> a2 = new HashSet<String>().stream();
    • 还有其他的子类，如 LinkedList, LinkedSet, TreeSet, Vector 等
  • Arrays.stream 可以将数组转为 Stream
    Stream<String> b1 = Arrays.stream("a,b,c,d,e".split(","), 3, 5);
  • 利用 Stream 类进行转化
    • of 方法，直接将数组转化
    Stream<Integer> c1 = Stream.of(new Integer[5]);
    Stream<String> c2 = Stream.of("a,b,c".split(","));
    Stream<String> c3 = Stream.of("a", "b", "c");
    • empty 方法，产生一个空流
    Stream<String> d1 = Stream.empty();
  • 利用 Stream 类进行转化
    • generate 方法，接收一个 Lambda 表达式
    Stream<String> e1 = Stream.generate(()->"hello");
    Stream<Double> e2 = Stream.generate(Math::random);
    • iterate 方法，接收一个种子，和一个 Lambda 表达式
    Stream<BigInteger> e3 = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
  • 其他类 / 方法产生 Stream 流
    • Files.lines 方法
    Stream<String> contents = Files.lines(Paths.get("C:/abc.txt"));
    • Pattern 的 splitAsStream 方法
    Stream<String> words = Pattern.compile(",").splitAsStream("a,b,c");

# 基本类型流

  • IntStream，LongStream，DoubleStream
IntStream s1 = IntStream.of(1,2,3,4,5);
s1 = Arrays.stream(new int[] {1,2,3});        
s1 = IntStream.generate(()->(int)(Math.random() * 100));        
s1 = IntStream.range(1,5); //1,2,3,4  step 1        
s1 = IntStream.rangeClosed(1,5); //1,2,3,4,5
IntStream s2 = IntStream.of(1,2,3,4,5);
Stream<Integer> s3 = s2.boxed();
IntStream s5 = s3.mapToInt(Integer::intValue);
# 并行流
  • 使得所有的中间转换操作都将被并行化
  • Collections.parallelStream () 将任何集合转为并行流
  • Stream.parallel () 方法，产生一个并行流
IntStream s1 = IntStream.range(1,10000000);
long evenNum = s1.parallel().filter(n->n%2==0).count();
System.out.println(evenNum);
  • 注意：需要保证传给并行流的操作不存在竞争
# 3.Stream 的转换
# 过滤 filter
  • filter(Predicate<? super T> predicate)
  • 接收一个 Lambda 表达式，对每个元素进行判定，符合条件留下
Stream<Integer> s1 = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> s2 = s1.filter(n -> n>2);
s2.forEach(System.out::println);
//3, 4, 5
# 去重 distinct
  • distinct()
  • 对流的元素进行过滤，去除重复，只留下不重复的元素
// 基本类型包装类对象去重
Stream<Integer> s1 = Stream.of(1, 1, 2, 2, 3, 3);
Stream<Integer> s2 = s1.distinct();
s2.forEach(System.out::println);
// 1, 2, 3
// 自定义对象的去重
ArrayList<Student> students = new ArrayList<Student>();
students.add(new Student("Tom", 20));
students.add(new Student("Tom", 20));
students.add(new Student("Jerry", 20));
students.add(new Student("Jerry", 18));
// 先对象的 hashCode 再调用 equals 方法进行判重
Stream<Student> s3 = students.stream().distinct();
s3.forEach(System.out::println);
# 排序 sorted
  • sorted()
  • 对流的基本类型包装类元素进行排序
Stream<Integer> s1 = Stream.of(3,2,4,1,5);
Stream<Integer> s2 = s1.sorted();
s2.forEach(System.out::println);
//1, 2, 3, 4, 5
  • 提供 Comparator，对流的元素进行排序
String[] planets = new String[] { 
        "Mercury", "Venus", "Earth", 
        "Mars", "Jupiter", "Saturn", 
        "Uranus", "Neptune" };
Stream<String> s3 = Stream.of(planets).sorted(
        Comparator.comparing(String::length));
s3.forEach(System.out::println);
  • 对流的自定义对象元素进行排序，调用对象的 compareTo 方法
ArrayList<Cat> cats = new ArrayList<>();
cats.add(new Cat(3));
cats.add(new Cat(2));
cats.add(new Cat(5));
cats.add(new Cat(1));
cats.add(new Cat(4));
Stream<Cat> s4 = cats.stream().sorted();
s4.forEach(System.out::println);
# 转化 map
  • 利用方法引用对流每个元素进行函数计算
Stream<Double> s1 = Stream.of(-1.5, 2.5, -3.5);
Stream<Double> s2 = s1.map(Math::abs);
s2.forEach(System.out::println);
  • 利用 Lambda 表达式对流每个元素进行函数计算
Stream<Integer> s3 = Stream.of(1,2,3,4,5);
Stream<Integer> s4 = s3.map(n->n*n);
s4.forEach(System.out::println);
  • 利用方法引用，对流每个元素进行函数计算返回 Stream
String[] planets = new String[] { 
        "Mercury", "Venus", "Earth"};
Stream<String> allLetters2 = 
        Stream.of(planets).flatMap(word -> letters(word));
allLetters2.forEach(System.out::print);
//flatMap 执行一对多的转换，然后将所有的 Map 都展开
//['M','e','r','c','u','r','y',
// 'V','e','n','u','s',
// 'E','a','r','t','h']
public static Stream<String> letters(String word)
{
    List<String> result = new ArrayList<>();
    for(int i=0;i<word.length();i++)
    {
        result.add(word.substring(i, i+1));
    }
    return result.stream();
}
  • 利用方法引用，对流每个元素进行函数计算返回 Stream，并合并
Stream<Stream<String>> allLetters = 
        Stream.of(planets).map(word -> letters(word));
allLetters.forEach(System.out::print);
//[['M','e','r','c','u','r','y'],
// ['V','e','n','u','s'],
// ['E','a','r','t','h']]
# 抽取 limit
// 获取前 n 个元素
Stream<Integer> s1 = Stream.of(1,2,3,4,5,6,7,8,9,10);
Stream<Integer> s2 = s1.limit(3);
s2.forEach(System.out::println);
# 跳过 skip
// 跳过前 n 个元素
Stream<Integer> s3 = Stream.of(1,2,3,4,5,6,7,8,9,10);
Stream<Integer> s4 = s3.skip(8);
s4.forEach(System.out::println);
# 连接 concat
//连接两个流
Stream<String> s5 = Stream.concat(letters("hello"), letters("world"));
s5.forEach(System.out::println);

# 额外调试 peek
Stream<Double> s1 = Stream.iterate(1.0, n -> n*2)
        .peek(n -> System.out.println("number:" + n)).limit(5);
s1.forEach(System.out::println);
# 4.Optional 类型
  • 一个包装器对象
  • 要么包装了类型 T 的对象，要么没有包装任何对象 (还是 null)
  • 如果 T 有值，那么直接返回 T 的对象
  • 如果 T 是 null，那么可以返回一个替代物
Optional<String> s1 = Optional.of(new String("abc"));
String s2 = s1.get();
System.out.println("s2: " + s2); //abc
Optional<String> s3 = Optional.empty();
String s4 = s3.orElse("def"); 
System.out.println("s4: " + s4); //def
# Optional<T> 创建
  • of 方法
  • empty 方法
  • ofNullable 方法，对于对象有可能为 null 情况下，安全创建
Optional<String> s5 = Optional.of(new String("abc"));
Optional<String> s6 = Optional.empty();
String s7 = null;
Optional<String> s8 = Optional.ofNullable(s7); 
//s7 不为 Null，s8 就是 s7, 否则 s8 就为 Optional.empty ()
# Optional<T> 使用
  • get 方法，获取值，不安全的用法
  • orElse 方法，获取值，如果为 null，采用替代物的值
  • orElseGet 方法，获取值，如果为 null，采用 Lambda 表达式值返回
  • orElseThrow 方法，获取值，如果为 null，抛出异常
  • ifPresent 方法，判断是否为空，不为空返回 true
  • isPresent (Consumer), 判断是否为空，如果不为空，则进行后续 Consumer 操作，如果为空，则不做任何事情
  • map (Function), 将值传递给 Function 函数进行计算。如果为空，则不计算
# Optional<T> 注意事项
  • 直接使用 get，很容易引发 NoSuchElementException 异常
  • 使用 isPresent 判断值是否存在，这和判断 null 是一样的低效
# 5. 流的计算结果
# 简单约简 (聚合函数)
  • count (), 计数
Stream<Integer> s1 = Stream.of(a);
long countResult = s1.filter(n-> n>0).count();
  • max (Comparator)，最大值，需要比较器
Stream<Integer> s2 = Stream.of(a);
Optional<Integer> maxResult = s2.max((n1,n2)->n1-n2);
  • min (Comparator)，最小值，需要比较器
Stream<Integer> s3 = Stream.of(a);
Optional<Integer> minResult = s3.min((n1,n2)->n1-n2);
  • findFirst (), 找到第一个元素
Stream<Integer> s4 = Stream.of(a);
Optional<Integer> first = s4.findFirst();
  • findAny (), 找到任意一个元素
Stream<Integer> s5 = Stream.of(a);
Optional<Integer> random = s5.findAny();
  • anyMatch (Predicate)，如有任意一个元素满足 Predicate，返回 true
Stream<Integer> s6 = Stream.of(a);
System.out.println(s6.anyMatch(n -> n>6));
  • allMatch (Predicate)，如所有元素满足 Predicate，返回 true
Stream<Integer> s7 = Stream.of(a);
System.out.println(s7.allMatch(n -> n>6));
  • noneMatch (Predicate)，如没有任何元素满足 Predicate，返回 true
Stream<Integer> s8 = Stream.of(a);
System.out.println(s8.noneMatch(n->n>100));
# 自定义约简
  • reduce，传递一个二元函数 BinaryOperator，对流元素进行计算
  • 如求和、求积、字符串连接等
Integer[] a = new Integer[] {2,4,6,8};
        
Stream<Integer> s1 = Stream.of(a);
Optional<Integer> sum = s1.reduce(Integer::sum);
System.out.println(sum.get());
Stream<Integer> s2 = Stream.of(a);
Optional<Integer> product = s2.reduce((x,y)->x*y);
System.out.println(product.get());
Stream<Integer> s3 = Stream.of(a);
Integer product3 = s3.reduce(1,(x,y)->x*y);
System.out.println(product3);
String[] b = new String[] {"abc","def","ghi"};
Stream<String> s4 = Stream.of(b);
String bigStr = s4.reduce("",(x,y)->x+y);
System.out.println(bigStr);
# 查看 / 遍历元素
  • iterator ()，遍历元素
  • forEach (Consumer)，应用一个函数到每个元素上
Integer[] a = new Integer[] {2,4,6,8};
        
Stream<Integer> s1 = Stream.of(a);
Iterator<Integer> it1 = s1.filter(n->n>2).iterator();
while(it1.hasNext()) {
    System.out.println(it1.next());
}
Stream<Integer> s2 = Stream.of(a);
s2.filter(n->n>2).forEach(System.out::println);
# 存放到数据结构中
  • toArray ()，将结果转为数组
  • collect (Collectors.toList ()), 将结果转为 List
//List
Stream<Integer> s1 = Stream.of(a);
List<Integer> list1 = s1.collect(Collectors.toList());
//Linkedlist
Stream<Integer> s2 = Stream.of(a);
List<Integer> list2 = s2.collect(Collectors.toCollection(LinkedList::new));
  • collect (Collectors.toSet ()), 将结果转为 Set
Stream<Integer> s3 = Stream.of(a);
Set<Integer> set1 = s3.collect(Collectors.toSet());
  • collect (Collectors.toMap ()), 将结果转为 Map
List<Person> persons = new ArrayList<Person>();
persons.add(new Person(1, "Jerry"));
persons.add(new Person(2, "Tom"));
// 将流存储为 Map
Stream<Person> s6 = persons.stream();
Map<Integer, String> map1 = s6.collect(Collectors.toMap(Person::getId, Person::getName));
  • collect (Collectors.joining ()), 将结果连接起来
// 将流变换为字符流，并连接起来
Stream<Integer> s4 = Stream.of(a);
String result = s4.map(String::valueOf).collect(Collectors.joining());
System.out.println(result); //2468
// 将流变换为字符流，并连接起来
Stream<Integer> s5 = Stream.of(a);
String result2 = s5.map(String::valueOf).collect(Collectors.joining(","));
System.out.println(result2); //2,4,6,8
# 流的高阶计算
  • 分组 groupingBy 和分区 partitionBy
  • 分组后的约简
    • counting
    • summing
    • maxBy
    • minBy
  • 以上方法均在 java.util.stream.Collectors 中
# 6. 流的应用
# Java Stream 的优点
  • 统一转换元素
  • 过滤元素
  • 利用单个操作合并元素
  • 将元素序列存放到某一个集合中
  • 搜索满足某些条件的元素的序列
  • 类似 SQL 操作，遵循 “做什么而非怎么做” 原则
  • 简化了串行 / 并行的大批量操作
# Java Stream vs 循环迭代代码
  • Stream 广泛使用 Lambda 表达式，只能读取外围的 final 或者 effectively final 变量，循环迭代代码可以读取 / 修改任意的局部变量。
  • 在循环迭代代码块中，可以随意 break/continue/return，或者抛出异常，而 Lambda 表达式无法完成这些事情。
  • Stream 流不是淘汰循环迭代代码，应该是两者相互搭配使用
# Stream 应用注意事项
  • 一个流，一次只能一个用途，不能多个用途，用了不能再用
  • 避免创建无限流
  • 注意操作顺序
  • 谨慎使用并行流
    • 底层使用 Fork-Join Pool，处理计算密集型任务
    • 数据量过小不用
    • 数据结构不容易分解的时候不用，如 LinkedList 等 –数据频繁拆箱装箱不用
    • 涉及 findFirst 或者 limit 的时候不用
# Stream vs Collection
  • Stream 和 Collection 两者可以互相转化
  • 如果数据可能无限，用 Stream
  • 如果数据很大很大，用 Stream
  • 如果调用者将使用查找 / 过滤 / 聚合等操作，用 Stream
  • 当调用者使用过程中，发生数据改变，而调用者需要对数据一致性有较高要求，用 Collection