• JDK8新特性之Stream流

    目录

    集合处理数据的弊端

    Stream流的获取方式

    对于Collection的实现类

    对于Map

    对于数组

    Stream常用方法介绍

    count

    forEach

    filter

    limit

    skip

    map

    sorted

    distinct

    match

    find

    max和min

    reduce

    mapToInt

    concat

    Stream结果收集

    结果收集到集合中

    结果收集到数组中

    对流中的数据做聚合计算

    对流中数据做分组操作

    对流中的数据做分区操作

    对流中的数据做拼接

    并行的Stream流

    串行的Stream流

    并行流

    线程安全问题

    集合处理数据的弊端

    当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就是 集合遍历

    看这个例子：

    1. public class StreamTest1 {
    2.  
    3.     @Test
    4.     public void test() {
    5.  
    6.         // 定义一个List集合
    7.         List list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");
    8.         
    9.         // 1.获取所有 姓张的信息
    10.         List list1 = new ArrayList<>();
    11.         for (String s : list) {
    12.             if (s.startsWith("张")) {
    13.                 list1.add(s);
    14.             }
    15.         }
    16.         
    17.         // 2.获取名称长度为3的用户
    18.         List list2 = new ArrayList<>();
    19.         for (String s : list1) {
    20.             if (s.length() == 3) {
    21.                 list2.add(s);
    22.             }
    23.         }
    24.         // 3. 输出满足条件的所有用户的信息
    25.         for (String s : list2) {
    26.             System.out.println(s);
    27.         }
    28.         
    29.     }
    30. }

    上面的代码针对与我们不同的需求总是一次次的循环循环循环.这时我们希望有更加高效的处理方式，这 时我们就可以通过JDK8中提供的Stream API来解决这个问题了。

    Stream更加优雅的解决方案：

    1.     @Test
    2.     public void test2(){
    3.  
    4.         List list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");
    5.  
    6.         list.stream()
    7.                 .filter(s->s.startsWith("张"))
    8.                 .filter(s->s.length()==3)
    9.                 .forEach(System.out::println);
    10.  
    11.     }

    看上面的代码够简短吧。获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简 洁直观，接下来我们就来学习学习stream流。

    Stream流的获取方式

    对于Collection的实现类

    首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实 现都可以通过steam方法来获取Stream流。

    1. public class getStreamTest {
    2.  
    3.     @Test
    4.     public void test1(){
    5.  
    6.         ArrayList objects = new ArrayList<>();
    7.         objects.stream();
    8.  
    9.         HashSet objects1 = new HashSet<>();
    10.         objects1.stream();
    11.         
    12.  
    13.         Vector objects2 = new Vector<>();
    14.         objects2.stream();
    15.     }
    16. }
      17.  

       

      对于Map
       

      Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map的 entrySet() 方法获取对应的key value的集合。
       

      1.     @Test
      2.     public void test2(){
      3.  
      4.         HashMap map = new HashMap<>();
      5.         map.entrySet().stream();
      6.         
      7.     }
       

      初学者可能不太好理解这个entrySet方法。这样想，map本来是存放一组组键值对的一个容器嘛，那我们要对容器里面的键值对进行遍历，但是遍历不了哇，要么就只能遍历键，要么就只能遍历值，无法完成我们的需求，所以有了entrySet方法，用来将map容器里面的这些键值对一组组的分好，这么一看，是不是这个容器就类似Collection了，这样我们每次遍历的时候每一项都是一个键值对映射项。看下面这个例子：
       

       

       

      对于数组
       

      在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所 有Stream接口中提供了静态方法of。
       

      1.     @Test
      2.     public void test3(){
      3.  
      4.         String[] a={"aa","bb","cc"};
      5.         Stream a1 = Stream.of(a);
      6.         a1.forEach(System.out::println);
      7.  
      8.         Integer[] b={1,23,8,5};
      9.         Stream b1 = Stream.of(b);
      10.         b1.forEach(System.out::println);
      11.  
      12.         //基本数据类型不行
      13.         int[] c={1,5,3,6};
      14.         Stream<int[]> c1 = Stream.of(c);
      15.         c1.forEach(System.out::println);
      16.     }
       

      但是注意：基本数据类型的数组不行，必须要是包装数据类型数组。
       

       

      Stream常用方法介绍
       

       

      Stream流的操作很丰富，这里只介绍一些常用的API。这些方法可以被分成两种：
       

      终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用，常用的有count方法和forEach方法。
       

      非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用。除了终结方法以外的都是非终结方法。
       

       

      Stream注意事项(重要)：
       

      • Stream只能操作一次
      • Stream方法返回的是新的流
      • Stream不调用终结方法，中间的操作不会执行
       

       

      count
       

      该方法返回一个long值，表示元素的个数
       

      1. public static void main(String[] args) {
      2.     long count = Stream.of("a1", "a2", "a3").count();
      3.     System.out.println(count);
      4. }
       

       

      forEach
       

      该方法接收一个Consumer函数式接口，会将元素遍历交给函数处理
       

      1. public static void main(String[] args) {
      2.     Stream.of("a1", "a2", "a3").forEach(System.out::println);;
      3. }
       

       

      filter
       

      filter方法的作用是用来过滤数据的。返回符合条件的数据。该接口接收一个Predicate函数式接口参数作为筛选条件
       

      1. public static void main(String[] args) {
      2.     Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
      3.         .filter((s)->s.contains("a"))
      4.         .forEach(System.out::println);
      5. }
       

       

      limit
       

      参数是一个long类型的数值，对该集合的前n个元素进行截取
       

      1. public static void main(String[] args) {
      2.     Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
      3.         .limit(3)
      4.         .forEach(System.out::println);
      5. }
       

       

      skip
       

      参数是一个long类型的数值，对该集合的前n个元素进行跳过，和limit恰好相反
       

      1. public static void main(String[] args) {
      2.     Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
      3.         .skip(3)
      4.         .forEach(System.out::println);
      5. }
       

       

      map
       

      该接口需要一个Function函数式接口参数，然后对元素进行遍历操作
       

      1.     @Test
      2.     public void test4(){
      3.  
      4.         String[] str= {"cc2","2cl2","3vv"};
      5.         List collect = Stream.of(str).map(String::length).collect(Collectors.toList());
      6.         System.out.println(collect);
      7.         
      8.     }
       

       

      sorted
       

      对数据进行排序，默认是可以自然排序，也可以自己实现排序规则
       

      1.     @Test
      2.     public void test5(){
      3.  
      4.         Integer[] a={1,8,2,6,58,6};
      5.  
      6.         Stream.of(a)
      7.               //.sorted()  //默认为自然排序
      8.                 .sorted((i,j)->j-i)//自定义规则，这里我们是逆序
      9.                 .forEach(System.out::println);
      10.     }
       

       

      distinct
       

      对数据进行去重操作。
       

      Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，我们是需要重写hashCode和equals方法来定义规则。
       

      1.     @Test
      2.     public void test6(){
      3.  
      4.         Integer[] a={1,8,2,6,58,6};
      5.  
      6.         Stream.of(a)
      7.               //.sorted()  //默认为自然排序
      8.                 .sorted((i,j)->j-i)//自定义规则，这里我们是逆序
      9.                 .distinct()
      10.                 .forEach(System.out::println);
      11.     }
       

       

      match
       

      如果需要判断数据是否匹配指定的条件，可以使用match相关的方法
       

       
 
      boolean anyMatch(Predicate predicate); // 元素是否有任意一个满足条件 boolean allMatch(Predicate predicate); // 元素是否都满足条件
       
 
      boolean noneMatch(Predicate predicate); // 元素是否都不满足条件
       

       

      1. public static void main(String[] args) {
      2.     boolean b = Stream.of("1", "3", "3", "4", "5", "1", "7")
      3.         .map(Integer::parseInt)
      4.       //.allMatch(s -> s > 0)
      5.       //.anyMatch(s -> s >4)
      6.         .noneMatch(s -> s > 4);
      7.     System.out.println(b);
      8. }
       

      注意match是一个终结方法
       

       

      find
       

      如果我们需要找到某些数据，可以使用find方法来实现
       

       
 
      Optional findFirst();
       
 
      Optional findAny();
       

       

      1. public static void main(String[] args) {
      2.     Optional first = Stream.of("1", "3", "3", "4", "5", "1","7").findFirst();
      3.     System.out.println(first.get());
      4.     Optional any = Stream.of("1", "3", "3", "4", "5", "1","7").findAny();
      5.     System.out.println(any.get());
      6. }
       

       

      max和min
       

      如果我们想要获取最大值和最小值，那么可以使用max和min方法
       

       
 
      Optional min(Comparator comparator);
       
 
      Optional max(Comparator comparator);
       

       

      1. public static void main(String[] args) {
      2.     Optional max = Stream.of("1", "3", "3", "4", "5", "1", "7")
      3.         .map(Integer::parseInt)
      4.         .max((o1,o2)->o1-o2);
      5.     System.out.println(max.get());
      6.  
      7.     Optional min = Stream.of("1", "3", "3", "4", "5", "1", "7")
      8.         .map(Integer::parseInt)
      9.         .min((o1,o2)->o1-o2);
      10.     System.out.println(min.get());
      11. }
       

       

      reduce
       

      如果需要将所有数据归纳得到一个数据，可以使用reduce方法
       

      1. public static void main(String[] args) {
      2.     Integer sum = Stream.of(4, 5, 3, 9)
      3.         // identity默认值
      4.         // 第一次的时候会将默认值赋值给x
      5.         // 之后每次会将 上一次的操作结果赋值给x y就是每次从数据中获取的元素
      6.         .reduce(0, (x, y) -> {
      7.             System.out.println("x="+x+",y="+y);
      8.             return x + y;
      9.         });
      10.     System.out.println(sum);
      11.  
      12.     // 获取 最大值
      13.     Integer max = Stream.of(4, 5, 3, 9)
      14.         .reduce(0, (x, y) -> {
      15.             return x > y ? x : y;
      16.         });
      17.     System.out.println(max);
      18. }
       

       

      mapToInt
       

      如果需要将Stream中的Integer类型转换成int类型，可以使用mapToInt方法来实现
       

      1. public static void main(String[] args) {
      2.         
      3.         // Integer占用的内存比int多很多，在Stream流操作中会自动装修和拆箱操作
      4.         Integer arr[] = {1, 2, 3, 5, 6, 8};
      5.         Stream.of(arr)
      6.                 .filter(i -> i > 0)
      7.                 .forEach(System.out::println);
      8.         
      9.         // 为了提高程序代码的效率，我们可以先将流中Integer数据转换为int数据，然后再操作
      10.         IntStream intStream = Stream.of(arr)
      11.                 .mapToInt(Integer::intValue);
      12.         intStream.filter(i -> i > 3)
      13.                 .forEach(System.out::println);
      14.     }
       

       

      concat
       

      如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
       

      1. public static void main(String[] args) {
      2.     Stream stream1 = Stream.of("a","b","c");
      3.     Stream stream2 = Stream.of("x", "y", "z");
      4.  
      5.     // 通过concat方法将两个流合并为一个新的流
      6.     Stream.concat(stream1,stream2).forEach(System.out::println);
      7. }
       

       

      Stream结果收集
       

       

      结果收集到集合中
       

      1.     @Test
      2.     public void test7(){
      3.         List list = Stream.of("a", "b", "c")
      4.                 .collect(Collectors.toList());
      5.         System.out.println(list);
      6.  
      7.         Set set = Stream.of("a", "b", "c")
      8.                 .collect(Collectors.toSet());
      9.         System.out.println(set);
      10.  
      11.         ArrayList arrayList = Stream.of("a", "b", "c")
      12.                 .collect(Collectors.toCollection(ArrayList::new));
      13.         System.out.println(arrayList);
      14.  
      15.         HashSet hashSet = Stream.of("a", "b", "c")
      16.                 .collect(Collectors.toCollection(HashSet::new));
      17.         System.out.println(hashSet);
      18.     }
       

       

      结果收集到数组中
       

      Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[],如果我们要指定返回的 类型，那么可以使用另一个重载的toArray(IntFunction f)方法
       

      1.     @Test
      2.     public void test8(){
      3.  
      4.         Object[] objects = Stream.of("a", "b", "c")
      5.                 .toArray();
      6.         System.out.println(objects);
      7.  
      8.         String[] strings = Stream.of("a", "b", "c")
      9.                 .toArray(String[]::new);
      10.         System.out.println(strings);
      11.     }
       

       

      对流中的数据做聚合计算
       

      1.     @Test
      2.     public void test9() {
      3.         
      4.         // 获取年龄的最大值
      5.         Optional maxAge = Stream.of(
      6.                 new Person("张三", 18)
      7.                 , new Person("李四", 22)
      8.                 , new Person("张三", 13)
      9.                 , new Person("王五", 15)
      10.                 , new Person("张三", 19)
      11.         ).collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));
      12.         System.out.println("最大年龄：" + maxAge.get());
      13.         
      14.         // 获取年龄的最小值
      15.         Optional minAge = Stream.of(
      16.                 new Person("张三", 18)
      17.                 , new Person("李四", 22)
      18.                 , new Person("张三", 13)
      19.                 , new Person("王五", 15)
      20.                 , new Person("张三", 19)
      21.         ).collect(Collectors.minBy((p1, p2) -> p1.getAge() - p2.getAge()));
      22.         System.out.println("最新年龄:" + minAge.get());
      23.         
      24.         // 求所有人的年龄之和
      25.         Integer sumAge = Stream.of(
      26.                 new Person("张三", 18)
      27.                 , new Person("李四", 22)
      28.                 , new Person("张三", 13)
      29.                 , new Person("王五", 15)
      30.                 , new Person("张三", 19)
      31.         ).collect(Collectors.summingInt(Person::getAge));
      32.         System.out.println("年龄总和：" + sumAge);
      33.         
      34.         // 年龄的平均值
      35.         Double avgAge = Stream.of(
      36.                 new Person("张三", 18)
      37.                 , new Person("李四", 22)
      38.                 , new Person("张三", 13)
      39.                 , new Person("王五", 15)
      40.                 , new Person("张三", 19)
      41.         ).collect(Collectors.averagingInt(Person::getAge));
      42.         System.out.println("年龄的平均值：" + avgAge);
      43.         
      44.         // 统计数量
      45.         Long count = Stream.of(
      46.                 new Person("张三", 18)
      47.                 , new Person("李四", 22)
      48.                 , new Person("张三", 13)
      49.                 , new Person("王五", 15)
      50.                 , new Person("张三", 19)
      51.         ).filter(p -> p.getAge() > 18)
      52.                 .collect(Collectors.counting());
      53.         System.out.println("满足条件的记录数:" + count);
      54.     }
       

       

      对流中数据做分组操作
       

      当我们使用Stream流处理数据后，可以根据某个属性将数据分组
       

      1.     @Test
      2.     public void test10() {
      3.  
      4.         // 根据账号对数据进行分组
      5.         Map> map1 = Stream.of(
      6.                 new Person("张三", 18, 175)
      7.                 , new Person("李四", 22, 177)
      8.                 , new Person("张三", 14, 165)
      9.                 , new Person("李四", 15, 166)
      10.                 , new Person("张三", 19, 182)
      11.         ).collect(Collectors.groupingBy(Person::getName));
      12.         map1.forEach((k, v) -> System.out.println("k=" + k + "\t" + "v=" + v));
      13.  
      14.         // 根据年龄分组 如果大于等于18 成年否则未成年
      15.         Map> map2 = Stream.of(
      16.                 new Person("张三", 18, 175)
      17.                 , new Person("李四", 22, 177)
      18.                 , new Person("张三", 14, 165)
      19.                 , new Person("李四", 15, 166)
      20.                 , new Person("张三", 19, 182)
      21.         ).collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年"));
      22.         map2.forEach((k, v) -> System.out.println("k=" + k + "\t" + "v=" + v));
      23.     }
       

       

      对流中的数据做分区操作
       

      Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个 false列表
       

      1.     @Test
      2.     public void test11() {
      3.         Map> map = Stream.of(
      4.                 new Person("张三", 18, 175)
      5.                 , new Person("李四", 22, 177)
      6.                 , new Person("张三", 14, 165)
      7.                 , new Person("李四", 15, 166)
      8.                 , new Person("张三", 19, 182)
      9.         ).collect(Collectors.partitioningBy(p -> p.getAge() > 18));
      10.         map.forEach((k, v) -> System.out.println(k + "\t" + v));
      11.     }
       

       

      对流中的数据做拼接
       

      Collectors.joining会根据指定的连接符，将所有的元素连接成一个字符串
       

      1.     @Test
      2.     public void test12() {
      3.  
      4.         String s1 = Stream.of(
      5.                 new Person("张三", 18, 175)
      6.                 , new Person("李四", 22, 177)
      7.                 , new Person("张三", 14, 165)
      8.                 , new Person("李四", 15, 166)
      9.                 , new Person("张三", 19, 182)
      10.         ).map(Person::getName)
      11.                 .collect(Collectors.joining());
      12.         // 张三李四张三李四张三
      13.         System.out.println(s1);
      14.  
      15.         String s2 = Stream.of(
      16.                 new Person("张三", 18, 175)
      17.                 , new Person("李四", 22, 177)
      18.                 , new Person("张三", 14, 165)
      19.                 , new Person("李四", 15, 166)
      20.                 , new Person("张三", 19, 182)
      21.         ).map(Person::getName)
      22.                 .collect(Collectors.joining("_"));
      23.         // 张三_李四_张三_李四_张三
      24.         System.out.println(s2);
      25.  
      26.         String s3 = Stream.of(
      27.                 new Person("张三", 18, 175)
      28.                 , new Person("李四", 22, 177)
      29.                 , new Person("张三", 14, 165)
      30.                 , new Person("李四", 15, 166)
      31.                 , new Person("张三", 19, 182)
      32.         ).map(Person::getName)
      33.                 .collect(Collectors.joining("_", "###", "$$$"));
      34.         // ###张三_李四_张三_李四_张三$$$
      35.         System.out.println(s3);
      36.     }
       

       

      并行的Stream流
       

       

      串行的Stream流
       

      我们前面使用的Stream流都是串行，也就是在一个线程上面执行。
       

      1. @Test
      2. public void test01(){
      3.     Stream.of(5,6,8,3,1,6)
      4.         .filter(s->{
      5.             System.out.println(Thread.currentThread() + "" + s);
      6.         return s > 3;
      7.     }).count();
      8. }
       

       
 
      Thread[main,5,main]5
       
 
      Thread[main,5,main]6
       
 
      Thread[main,5,main]8
       
 
      Thread[main,5,main]3
       
 
      Thread[main,5,main]1
       
 
      Thread[main,5,main]6
       

       

       

      并行流
       

      parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速度。
       

      我们可以通过两种方式来获取并行流：
       

      • 通过List接口中的parallelStream方法来获取
      • 通过已有的串行流转换为并行流(parallel)
       

       

      1. @Test
      2. public void test02(){
      3.     List list = new ArrayList<>();
      4.     // 通过List 接口 直接获取并行流
      5.     Stream integerStream = list.parallelStream();
      6.  
      7.     // 将已有的串行流转换为并行流
      8.     Stream parallel = Stream.of(1, 2, 3).parallel();
      9. }
       

       

      测试：
       

      1. @Test
      2. public void test03(){
      3.     Stream.of(1,4,2,6,1,5,9)
      4.         .parallel() // 将流转换为并发流，Stream处理的时候就会通过多线程处理
      5.         .filter(s->{
      6.             System.out.println(Thread.currentThread() + " s=" +s);
      7.             return s > 2;
      8.         }).count();
      9. }
       

       
 
      Thread[main,5,main] s=1
       
 
      Thread[ForkJoinPool.commonPool-worker-2,5,main] s=9 Thread[ForkJoinPool.commonPool-worker-6,5,main] s=6 Thread[ForkJoinPool.commonPool-worker-13,5,main] s=2 Thread[ForkJoinPool.commonPool-worker-9,5,main] s=4 Thread[ForkJoinPool.commonPool-worker-4,5,main] s=5 Thread[ForkJoinPool.commonPool-worker-11,5,main] s=1
       

       

       

      线程安全问题
       

      在多线程的处理下，肯定会出现数据安全问题。如下：
       

      1.     @Test
      2.     public void test9(){
      3.  
      4.         ArrayList arrayList1 = new ArrayList<>();
      5.         for (int i=0;i<1000;i++){
      6.             arrayList1.add(i);
      7.         }
      8.  
      9.         ArrayList arrayList2 = new ArrayList<>();
      10.         arrayList1.parallelStream()
      11.                 .forEach(arrayList2::add);
      12.         System.out.println(arrayList2.size());
      13.     }
       

      运行以后结果并不是1000
       

       

      针对这个问题，我们的解决方案有哪些呢？
       

      • 加同步锁
      • 使用线程安全的容器
      • 通过Stream中的toArray/collect操作
       

       

      1.     //加同步锁
      2.     @Test
      3.     public void test9() {
      4.  
      5.         Object o = new Object();
      6.         ArrayList arrayList1 = new ArrayList<>();
      7.         for (int i = 0; i < 1000; i++) {
      8.             arrayList1.add(i);
      9.         }
      10.  
      11.         ArrayList arrayList2 = new ArrayList<>();
      12.         arrayList1.parallelStream()
      13.                 .forEach((a) -> {
      14.                     synchronized (o) {
      15.                         arrayList2.add(a);
      16.                     }
      17.                 });
      18.         System.out.println(arrayList2.size());
      19.     }
       

       

      1.     //使用线程安全的容器
      2.     @Test
      3.     public void test10() {
      4.  
      5.         Vector objects = new Vector<>();
      6.         for (int i = 0; i < 1000; i++) {
      7.             objects.add(i);
      8.         }
      9.  
      10.         Vector vector = new Vector<>();
      11.         objects.parallelStream()
      12.                 .forEach((a) -> {
      13.                     vector.add(a);
      14.                 });
      15.         System.out.println(vector.size());
      16.     }
       

       

      1.     //将线程不安全的容器包装为线程安全的容器
      2.     @Test
      3.     public void test11() {
      4.         List listNew = new ArrayList<>();
      5.  
      6.         List synchronizedList = Collections.synchronizedList(listNew);
      7.  
      8.         IntStream.rangeClosed(1, 1000)
      9.                 .parallel()
      10.                 .forEach(i -> {
      11.                     synchronizedList.add(i);
      12.                 });
      13.         System.out.println(synchronizedList.size());
      14.     }
       

       

      1.     //通过Stream中的 toArray方法或者 collect方法来操作
      2.     @Test
      3.     public void test12() {
      4.  
      5.         List list = IntStream.rangeClosed(1, 1000)
      6.                 .parallel()
      7.                 .boxed()
      8.                 .collect(Collectors.toList());
      9.         System.out.println(list.size());
      10.     }
       

      
                
                    
                

                
    17. 

                    相关阅读:
      
                    
解决方案：AI赋能工业生产3.0，从工业“制造”到“智造”                            
      
Java安全—CommonsCollections1                            
      
LeetCode - 二维数组及滚动数组                            
      
C++笔记之文档术语——将可调用对象作为函数参数                            
      
基于三维GIS开发的水电工程建设方案                            
      
获取所有非manager的员工emp_no                            
      
Linux系统下centos中在线添加硬盘后不重启在线扩容linux系统目录不重启系统                            
      
IDEA04：动态加载配置文件                            
      
安装jdk、tomcat、mysql                            
      
从心灰意冷到自学Java3个月顺利拿到offer，多亏这份文档                            
      
                          
                
      18. 
                
    18. 
                    原文地址：https://blog.csdn.net/weixin_56644618/article/details/127984094
                
      19.