《JDK8 实战》笔记——1.Lambda&Stream流库

古城微笑少年丶 2023-09-30 10:33 13阅读 0赞

《Java8 实战》

**第 1 章**

### 为什么关心JAVA 8 ？——改变很多，改变影响很大；简洁代码-Lambda，多核并行-Stream，线程与锁； ###

1.  流处理，将不相关的操作分别交给多个CPU内核并行执行；
2.  把代码作为参数传递给方法；
3.  并行-共享数据，对于流的并行，需要输入"纯函数"，不能多个进程同时访问该共享变量，因此用"代码替换对象"；
4.  对集合的操作，更多的关注"做什么"而不是给出Iterator遍历集合元素的过程；
5.  编程的目的在于操作值（对象），方法/类看做是次要的/辅助的，现在将方法/Lambda也看做"一等公民";
6.  方法引用，充分利用已有的方法ckass::method，简化写法；
7.  Lambda与匿名类，配合方法引用，Lambda更加简洁；
8.  集合类-for each "外部迭代"，流-forEach() "内部迭代"；
9.  多线程的问题——变量同步；Stream的设计，包括里面的各个方法在实际的时候就考虑到，让这些操作之间无冲突/可并行；这种思想有点像是"分治"或者"归并"；
10. 关于接口，如果JDK的某些接口改进，要增加功能，这将会带来大问题——它的子类太多了，每个子类都要修改，解决——允许接口有实例方法，即default方法，与普通方法一样，能被继承/重写/重载；这样的话，增加了已发布接口的新功能而不破坏已有的实现；
11. 接上面的问题，这样可能会导致C++父类多继承的典型问题——"菱形继承"，给出测试如下，结论：编译器不让一个类继承两个具有"完全一样的"default方法的接口；可以继承继承两个具有"重载关系的"default方法的接口；因为两个父类接口的同名default方法仅返回值不同，不构成"重载关系"，因此也是不允许的；

package cn.ActionInJ8;
    
    /**
    * Created by 11103381 on 2019/8/29.
    */
    public class TestDefaultMethod_01 implements IA, IB {
    }
    
    interface IA {
      default void doSth(){//第1类default方法，与B完全一样
        System.out.println("IA");
      }
    
      default void doIt() {//第2类default方法，与B是"重载"关系—
        System.out.println("do It");
      }
    
      default void okay() {//第3类default方法，与B是"非重载"关系——仅仅返回值不同
        System.out.println("do It");
       }
    
      default void oJbKay() {//第4类default方法，与B是"重载"关系——不仅返回值不同，传参也不同
        System.out.println("do It");
      }
    }
    
    interface IB {
    // default void doSth(){//上面继承A、B会编译错误
    // System.out.println("IB");
    // }
    
      default void doIt(String s) {
        System.out.println("do It " + s);
      }
    
    // default String okay(){//上面继承A、B会编译错误
    // return "do It";
    // }
    
      default String oJbKay(String s) {
        return "do It，oJbKay";
      }
    }

**第 2 章**

行为参数化：定义一种行为，或者叫"功能/操作"，以代码块的形式；把这个代码块准备好后，丢给其他程序，这样其他程序需要调用的时候才会调，这个代码块被"推迟执行"；

*  不断变化的需求；需求变化，比如说，更小的需求变化，不推荐的做法是：新写一个方法，复制旧方法的大量代码，改其中一个小逻辑；思想：将这些"比方法还小的功能抽象出来"，让代码尽可能逻辑清晰-精简代码；那不用新方法实现新需求，该怎么办？——用代码块，即让"行为参数化"；

具体操作：写个接口-把这个接口对象作为参数传递到旧方法中-接口里面定义了一个抽象方法-根据不同的需求去写这个接口不同的实现类-让这些实现类的对象作为不同方法的"载体"传入旧方法去实现不同的功能；

*  以上的做法有一点不足——真正需要的不是这个接口对象，而是它的方法实现，这个方法的使用必须依赖这个接口对象，每次使用的时候，需要先定义接口的实现类实现方法；还有一点，这种接口有一个最大的特点，只有一个特定功能，即一个抽象方法！（这个规律可以利用一下-注解）
 *  面对上面的问题，第一次改进：不去写这个接口的实现类，而是使用匿名类，这样项目工程就会少很多类；结果发现，需要写的代码并没有减少多少，还有个问题，如果在一个方法内去new匿名类的对象，当方法内部/形参、匿名类的内部、匿名类的实现方法的内部 都有一个重名的变量的时候，对这个变量的操作规则就很复杂（配合this关键字），如下面的测试例子；
 *  尝试使用Lambda代替接口对象；eg：Runnable和Comparator，Lambda替换run()和compare(T t1,T t2);

### 关于匿名类的有趣的测试： ###

package cn.ActionInJ8;
    
    import org.junit.Test;
    
    /**
    * Created by 11103381 on 2019/8/29.
    */
    public class TestAnonymousClass {
    int num = 10;//成员变量
    
    @Test
    public void printnum(int num) {
        System.out.println(num);//输出方法的形参
        System.out.println(this.num);//对于成员方法，this指代当前的类的对象，因此这个this.num输出(1)定义的成员变量"Class"
    }
    
    @Test
    public void doSth() {
        int value = 10;//(1)
        TestAnonymous ta = new TestAnonymous() {
            int value = 9;//(2)
    
            @Override
            public void doA() {
                int value = 8;//(3)
                System.out.println(value);//输出doA()内部的局部变量(3) 8；
                System.out.println(this.value);//输出doA所在的匿名类的内部定义的成员变量(2) 9；
                this.value++;//允许修改，这里value不是final；
                value++;//允许修改，这里value不是final；
            }
        };
        ta.doA();
    }
    
    // 当在一个方法A内使用匿名类new一个接口对象，并且在匿名内内部（无论是抽象方法内/外）使用该方法A的形参 的时候，这个形参必须是final(隐式)，不能被修改；
    @Test
    public void getnum(int num) {
    TestAnonymous ta = new TestAnonymous() {
        // int myInt = num++;//error，不能修改形参num；
    
        @Override
            public void doA() {
                System.out.println(num);
                // num++;//error，不能修改形参num；
            }
        };
    }
    
    interface TestAnonymous {
        void doA();
    }

（图）

![c8d99f6079ff41f2d3414ae1d0f2d0c1.png][]

匿名类中访问外部变量为隐式的final类型

补充：这里再补充一个例子，关于lambda与匿名类的this关键字的含义

![5d04e8437f6712c75696948e6fa21249.png][]

this关键字在内部类和lambda表达式中的区别

匿名类的被实现的方法的方法体内的this，指的是这个匿名类的对象；外部类对象this需要显示的指明，即OuterClass.this；

而lambda的this指的是外部类对象；

有趣的帖子：[Java匿名类遇上final - 简书][Java_final -]（图）

### 1. final遇见内部类 ###

Java中要求如果方法中定义的中类如果引用方法中的局部变量，那要要求局部变量必须要用final修饰（JDK8中已经不需要，但是本质也是和final类似——只读），实例代码如下：

interface Inner{
      void method();
    }
    
    class Outer{
        public Inner createInner(){
            final int a = 12;
            final Map map = new HashMap();
            Inner inner = new Inner(){
                public void method(){
                    int b = a + 1;
                    System.out.println(" in Inner, b=" + b);
                    map.put("innerKey", "innerValue");
                }
            };
            System.out.println("in Outer, createInner finish！");
            return inner;
        }
    
        public static void main(String []args){
            Inner inner = new Outer().createInner();
            inner.method();
        }
    }

**输出如下**：

> in Outer, createInner finish！  
> in Inner, b=13

**Note**: 上述代码仅仅是展示使用，其中`createInner()`方法中的`map`变量是存在内存泄漏的，因为外界无法访问他，但是却会被一致持有。关于内存泄漏的问题，通过查看上述代码便后的class文件的内容即可发现。

上述文件编译后，生成了三个文件

1.  Inner.class
2.  Outer.class
3.  Outer$1.class
    
    打开Outer$1.class可以看到如下内容：

class Outer$1 implements Inner {
          Outer$1(Outer this$0, int var2, Map var3) {
              this.this$0 = this$0;
              this.val$a = var2;
              this.val$map = var3;
          }
    
          public void method() {
              int b = this.val$a + 1;
              System.out.println(" in Inner, b=" + b);
              this.val$map.put("innerKey", "innerValue");
          }
      }

可以看到编译后的内容，Inner匿名类拥有另一个带有三个参数的构造方法，

*  **`Outer this$0`**： 也就是拥有了Outer(外部类)当前对象的一个引用，所以我们Inner的子类中，可以通过`Outer.this`访问外部`Outer`类的当前实例。
 *  **`var2`**: 此处应该为`Outer createInner()`方法中的局部变量a
 *  **`var3`**: 此处应该为`Outer createInner()`方法中的局部变量Map

通过上述编译后的代码，我们大概可以明白为什么匿名类可以访问其外部数据的原因，接下来我们可以讨论一下**为什么要对`createInner()`中的局部变量`a`, `map`用final进行修饰**。

为了简化表述，以下将Inner匿名类里面的a表述为`Inner().a`， 将`createInner()`方法中的a表示为 `createInner.a`.

**通过编译后的代码可以看出来，`Inner().a`和`createInner.a`不是同一个对象**(在内存中不是同一个）， 同样的，两个map（值，存在于堆）在内存中也是不同的，**但是两个map的都指向了堆上的\*\*\*\*同一个\*\*\*\*`HashMap`对象**。理论上我们是可以重新设置`Inner().a`和`Inner().map`的值的，但是java编译器并不允许这样做， 具体原因我认为可能是如下原因：

> 在匿名类内部访问外面的变量看起来是一个很正常的需求，而且直观看起来应该是同一个东西。但是**在方法调用结束以后局部变量会被销毁**（栈里面的内容，也就是`createInner.a`, `createInner.map`。**如果是同一个东西的话，那么意味着jvm在方法调用结束以后还不能销毁这些局部变量，需要将这些局部变量的生命周期保持到和Inner一样长**，这样让jvm的实现起可能会更为复杂（**提升这些变量的生命周期**）。

所以，为了实现在`Inner`中可以访问`createInner()`中的`a`, `map`，同时他们看起来和`createInner()`中的一样（一致），并且**避免JVM对对象生命周期的管理过于复杂**，采用了一个中折中的办法：

> 1.  将被用到的变量作为`Inner`的构造函数参数传入并在`Inner`内部设置对应的实例（private)。
> 2.  将`createInner().a`, `createInner().map`设置为final，并且**匿名类类部不可以修改对应实例属性的值**，保证一致性。

通过上述的 1中，可以很自然实现在`Inner`中很自然的访问`createInner`中局部变量的值；由于`Inner`中使用的变量实际上和外部函数中的局部变量是不一样的，通过上述2可以保证他们一致（**都不允许修改了，肯定一致**）， 否则开发者在内部修改值，但是却不会影响到外面的局部变量，这会让人困惑（天然看起来应该是一个东西啊，但是却不能一起变化）。

### 2. 闭包 ###

此处引出了Java对闭包的支持，其实Java目前是支持了闭包的，匿名类就是一个典型的例子。将**自由变量**（`createInner.a`,`createInner.map`)**封装到Inner中**，但是Java的闭包确实**有条件的闭包**，因为Java只实现了capture-by-value， 只是把局部变量的值copy到了匿名类中， 没有实现capture-by-reference。如果是capture-by-reference的实现方式，可能需要将局部变量提升到对象中（也就是将局部变量的生命周期延长，变为和`Inner`类一样长, 那么在`createInner()`执行完毕以后，就不会销毁 `a`, `map`了)。

关于闭包的定义：**[Ruby之父松本行弘在《代码的未来》一书中解释的最好：闭包就是把函数以及变量包起来，使得变量的生存周期延长][Ruby]**。

### 3. 内存泄漏 ###

Java中的闭包并没有真正的实现延长生命周期， 但是间接实现了`createInner.map`的生命周期，**因为`Inner.map`是一个对实际的`HashMap()`（位于堆中）对象的引用**， 所以在`createInner()`方法中创建，但是却不会在该方法执行以后被`GC`回收， 该对象的生命周期和其创建`Inner`实例一样长。在本例中的代码的**内存泄漏**就由此而生。也就是说，如果是仅仅使用方法的局部变量（如map），而不是把map赋值给Inner的一个对象作为方法的返回值，则map在方法调用完成后就会被GC回收。

**第 3 章**

### Lambda表达式 ###

1.  函数式接口；第2章说过，"让这些接口的实现类的对象作为不同方法的"载体"传入"，这种接口有一个最大的特点，只有一个特定功能，即一个抽象方法！现在使用注解来标记这种类型的接口，@FunctionalInterface即函数式接口（编译时会检查，抽象方法超过1个会报错）；
2.  关于基本类型的"装箱与拆箱"，**自动装箱会影响性能**，如int型到Integer对象会增加所需的内存，并且需要额外的内存搜索来获取被"包装起来"的原始基本类型的值；在函数式接口中的泛型T，如Integer，再使用过程中带来了优化，避免了"自动装箱"来提升性能；
3.  Lambda与异常；**JDK自带的函数式接口不允许抛出受检查异常（如常见的IOException）**，而自己定义的@FunctionalInterface可以抛出；**IO异常很常见，但又不能抛出，怎么解决呢**？

思路1：在方法体，即Lambda的\{\}内部try/catch，缺点是只能自己catch这个异常，如果自己处理不了这个异常怎么办？；  
思路2：**优雅的做法——利用泛型**，具体的代码示例如下：

import [java.io](http://java.io/).IOException;
        import java.util.stream.Stream;
    
        /**
         * Created by 11103381 on 2019/8/29.
         */
        public class TestFuntionalInterface {
    
            private static void UseInterface(IfTestFuntionalInterface_02 a) {
                try {
                    a.doA();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            @Test
            public void func_01() {
                UseInterface(() -> {//自定义的函数式接口可以抛出受检查异常
                    System.out.println("A");
                    throw new IOException();
                });
            }
    
            @Test
            public void func_02() {
                //传入Consumer
                // Stream.of(1,2,3,4,5).forEach(i->{throw new **IOException()**;});//**编译错误**，Consumer不能抛出受检查异常，如IOException；
                Stream.of(1, 2, 3, 4, 5).forEach(i -> {
                    throw new RuntimeException();
                });//通过编译，可以抛出非检查异常，如RuntimeException；
            }
    
            //**针对上面不能抛出受检查异常的问题**，**编写一个泛型方法对异常进行包装**
            static <E extends Exception> void doThrow(Exception e) throws E {
                throw (E) e;
            }
    
            @Test
            public void func_03() {//
                Stream.of(1, 2, 3, 4, 5).forEach(i -> {
                    doThrow(new IOException());
                });//编译成功，实现了Consumer抛出受检查异常
            }
        }
    
        interface IfTestFuntionalInterface_01 {
            void doA() throws RuntimeException;
    
            default void doB() {
            }
        }
    
        @FunctionalInterface
        interface IfTestFuntionalInterface_02 {
            void doA() throws IOException;
        }

*  Lambda表达式可以直接赋值给该函数式接口的引用（就像是一个对象赋值给一个引用），那么**Lambda是不是一个Object对象呢？并不是！**测试如下：

@Test
    public void func_04() {//Lambda是不是Object对象？
      IfTestFuntionalInterface_01 IF = ()->System.out.println("A");//编译成功，Lambda能直接赋值给该函数式接口的引用；
      IF.doB();
      // Object o1 = ()->{System.out.println("A");};//编译失败Lambda不能直接赋值给Object；
      // ()->{System.out.println("A");}.doB();//编译失败，Lambda不能直接作为句柄访问接口的方法；
    }

*  **Lambda访问方法的局部变量**；举个例子如下，

public Runnable func_05() {
      int a = 10;
      List<String> l = new ArrayList<>();
      l.add("aaa-");
      a++;
      Runnable r = () -> {
        System.out.println("Run!" + (l.add("bbb-")));//编译成功，因为引用是final，里面的内容可以改；
    // System.out.println(a);//这句如果加上去，则编译错误，编译器提示Lambda使用的a为隐式的final；
      };
      a++;
      r.run();
      System.out.println(l);//
      System.out.println(a);
      return r;
    }

**为什么必须是final的？**还有个问题，Lambda访问的是"真正的"方法局部变量a和l吗？不是！

因为当这个方法有返回值，如返回这个Runnable r时候，方法执行完，返回Runnable对象，方法的局部变量被回收（局部变量和引用在虚拟机栈上，对象本身放在堆里面，引用指向的对象也因为可达性分析没有root连接的被GC），而这个Runnable作为一个仍然存在的返回值，仍然"持有"a和l，这是矛盾的！

怎么解决？——实际上，Runnable作为一个内部类的对象，其Lambda获取的a和l是局部变量的"副本"，这样就可以在方法结束后仍然有局部变量指向的对象的引用；这又出现了一个问题！当Lambda内部修改这个副本的时候，不就导致了Lambda内的a和l，与外部局部变量的a和l的值"不一致"吗？（因为一开始的目的是让"Lambda访问外部的局部变量"，也就是说二者至少看上去要是"一致的"）

怎么办？——让他们都是final的就可以了，都不给修改，这样就"一致"了，看上去"像是Lambda访问了外面的方法内的局部变量"，"好像延长了局部变量的生命周期";

如果觉得难以理解，记住即可，与匿名类类似，访问的局部变量必须是隐式的final；

1.  **方法引用/构造函数引用；——Lambda的语法糖**！  
    利用现有的方法（JDK）自带的，减少代码的复制，进一步精简；

（1）方法引用

1. 1个参数-对象a作为toString()方法的调用者，可以省略；eg：(Interger a)->a.toString(); 转成 Integer::toString；  
2. 1个参数-对象s作为println()的传入参数，可以省略；eg：(String s)->System.out.println(s); 转成System.out::println；  
3. 无参数-无参数传入，调用Thread类的方法；eg：()→Thread.currentThread();转成Thread::currentThread;  
4. 2个参数，a.doSth(b)的形式，可以省略，要注意顺序；eg:(str,i)→str.subString(i);转成String::subString;

注意：**这里仅关注参数的个数和形式，不关注是否有返回值**；

（2）构造函数引用  
构造函数其实是隐式的static的，**把它看作是名字为new的static函数即可**；需要注意构造函数的传参个数；eg：

1.无参构造器；  
Supplier<Apple> s = Apple::new; Apple apple1 = s.get();//Supplier<T>/T get() 无传入，返回一个T对象；

2.一个参数；  
Function<Integer, Apple> f = Apple::new; Apple apple2 = f.apply(10);//Function<T,R>/R get(T) 传入T类对象，返回一个R对象；

3.两个参数；  
BiFunction<Integer,String, Apple> bf = Apple::new; Apple apple3 = bf.apply(10,"BigApple");//Function<T1,T2,R>/R get(T1,T2) 传入T1和T2两个对象，返回一个R对象；

**构造函数引用的好处**：**延迟new对象**，即Lambda表达式仅仅是一种操作-产生对象的工具，什么时候产生对象取决于我们什么时候需要这个对象(调用上面的get/apply方法)；eg：

static Map<String,Function<Double,Fruit_01>> fruitFactory = new HashMap<>();//key-ID,value-产生不同水果的方法；
    static {
      fruitFactory.put("apple",Apple::new);
      fruitFactory.put("Orange",Orange::new);
    //...
    }
    static Fruit_01 getOneFuit_01(String name,double weight){
      return fruitFactory.get(name.toLowerCase()).apply(weight);
    }
    @Test
    public void func_01() {
      Fruit_01 apple = getOneFuit_01("APPLE",10);//来10斤苹果；
    }

（3）嵌套使用

@Test
    public void func_02() {//嵌套使用方法引用
      List<Apple> la = new ArrayList<>(Arrays.asList(new Apple(15),new Apple(10)));
    **  la.sort(Comparator.comparing(Apple::getWeight));**//comparing传入一个Function，对Function的apply的返回值调用compareTo：(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
      la.stream().forEach(System.out::print);
    }

\***7. 谓词复合**(解释式编程，像是口述告诉程序的流程怎么走)；

（1）比较器Comparator 逆序/比较链  
.reversed()对比较器"取反"；.thenComparing()如果前面的比较得到的两个相等的元素，则按照下一个比较器继续比较；

（2）Predicate<T>  
可以使用.and(Predicate<T>)/.or(Predicate<T>)连接两个断言对象，表示与/或关系；p.negate()返回一个对断言的逻辑取"非"的Predicate对象；

（3）Consumer<T>  
.andThen()方法，连接两个Consumer<T>对象，相当于顺序执行，即传入一个对象T t，对其先后执行Consumer1.accept(t);Consumer2.accept(t');

(4)Function<T, R>  
.compose(Function<T> before)，接另一个Function对象，将T t传给前一个Function，before.apply(t)返回的值作为当前Function的输入；.andThen(Function<T> after)刚好与其相反；

**第 4 章**

引入流

**为什么引入JAVA8流？**

1.  直抒型编程，不关系怎么遍历集合、是否取出一些元素、是否需要中间容器...只关心一套流程下来每一步需要做什么；
2.  流的操作是"**惰性**"的，取值的时候才会执行；流不改变原来集合，**减少"无效的中间变量"的使用**；
3.  **充分利用CPU多核**并行能力（并行代码很难写，Stream的操作方法由JDK帮实现，**不用担心**处理数据任务并行而去**操心线程与加锁**）；

1.**流相关的概念**  
元素；源（集合）；单个操作（filter、map...）；流水线（多个操作的组合）；

2.**流与集合**

*  **流并不储存元素**。这些元素可能存储在底层的集合中，或这是按需生成。
 *  **流的操作不会修改其数据源**。例如，filter方法不会从新的流中移除元素，而是会生成一个新的流，其中不包含被过滤掉的元素。
 *  **流的操作是尽可能惰性执行的**。这意味着直至需要其结果时，操作才会执行。例如如果我们只想查找前5个长单词（长度大于x的String）而不是所有长单词，那么filter方法就会在匹配到第5个单词后停止过滤。
 *  Stream不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的Iterator。原始版本的Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的Stream，用户只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，**Stream会隐式地在内部进行遍历**，做出相应的数据转换。**Stream就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返**。
 *  **和迭代器又不同的是，Stream可以并行化操作**，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个item读完后再读下一个item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream的并行操作依赖于Java7中引入的Fork/Join框架来拆分任务和加速处理过程。
 *  **Stream的另外一大特点是，数据源本身可以是无限的**。获取一个数据源（source）→数据转换→执行操作获取想要的结果，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

3.关于流**只能遍历一次**

public class TestStream_01 {
    @Test
    public void func_01(){
      Stream s = Stream.of(8,3,9,7,7,1,9,9,5);
      s.forEach(System.out::println);
      s.forEach(System.out::println);//java.lang.IllegalStateException: stream has already been operated upon or closed
    }
    }

> 控制台输出：  
> java.lang.IllegalStateException: stream has already been operated upon or closed...

4.**外部迭代/内部迭代**？

有趣的小例子：A让B去把地上的所有玩具放到箱子里去：

（1）集合-显示的外部迭代  
A：地上有玩具吗？B：有，看到一个球；  
A：把球放到箱子里。还有吗？B：还有个娃娃；  
A：把娃娃放到箱子里。还有吗？B：还有...

（2）Stream-隐式的内部迭代  
A：把地上所有玩具放到箱子里。B：好的！

**好处**：  
1. B可以一手拿球，一手拿娃娃，一起放到箱子里；（**并行**）  
2. B可以选择先拿那个距离箱子最近的娃娃；（**顺序优化**）**Stream库的内部迭代可以自动选择一种适合硬件的数据表示和并行实现**，无需我们关心这些复杂的功能怎么实现；

5.流操作

*  中间操作：对流处理（内部迭代），然后生成个新的流作为返回值，进行接下来的流程；filter、sorted、map、limit、skip...；
 *  终端操作：生成结果，"生产线"停止；forEach、Match、collect、Reduce...；

**第 5 章**

\***使用流**

1.  筛选和切片

*  filter(Predicate<T> p) 接收一个Predicate，即对流元素遍历作为Predicate的参数-返回一个boolean，为true则将元素放入一个新的流，遍历完所有流元素，组后将生成的新流返回；
 *  distinct() 无参函数，相当于对每一个流元素判断是否存在于新流中，不存在则加入，存在则跳过，最后将这个不含重复元素的新流返回，有点像遍历集合元素放入Set后，返回这个Set；
 *  limit(Long n) 取流中的前n个元素，放入新流中后返回新流；
 *  skip(Long n) 跳过n个元素，把剩下的元素按序放入新流中后返回新流；

**1. 映射**

*  map(Function<T,R> f) 对流中的每个元素做映射，即T类型的流元素经过Function得到一个R类型的结果，将这个结果放入新的流，返回新流；
 *  ***flatMap(Function<T,R> f)** 对流中的每个元素做映射，仅仅针对每个映射后得到的结果是Stream的情况（例如之前元素是数组，转成流后，现在新流的每个流元素就变成Stream对象了），会自动地将新流的所有的Stream元素"合并"到另一个新流后返回；**一般配合数组的Arrays.stream()方法*\*，示例如下：

@Test
        public void func_02() {
            Stream<String> s = Stream.of("abc", "def", "gh");
            // s.map(str->str.split("")).forEach((ss)-> System.out.println(Arrays.toString(ss)));//流的每个元素变成String[],打印3个数组[a, b, c]，[d, e, f]，[g, h]
            // s.map(str->str.split("")).map(Arrays::stream).forEach(st->st.forEach(System.out::println));//每个String[]类型的元素变成了流，即现在的元素是3个Stream<String>
            s.map(str -> str.split("")).flatMap(Arrays::stream).forEach(System.out::println);//**基于上面一步，在将每个数组元素转成流后，将每个流类型的元素"合并"到一个新流里面，有点像addAll那种感觉**；
            System.out.println("-----example-----");
            Stream<Stream<String>> streamOfStream = Stream.of(Stream.of("a", "b"), Stream.of("c"), Stream.of("d", "e"));//Stream的元素是Stream
            // streamOfStream.map((Eachstream) -> (Eachstream)).forEach(System.out::println);//此时元素还是Stream<String>
            streamOfStream.flatMap( **Function.<Stream<String>>identity() **).
            forEach(System.out::println);//此时元素变成了**String,Function.identity()等效于**上面一句，即**(a)->(a)不做任何操作**返回；
        }

**2. 查找和匹配**

匹配都是"**终端操作**"

*  anyMatch(Predicate<T> t) 对流每个元素做匹配，只要有一个满足判断，则返回true；
 *  allMatch(Predicate<T> t) 对流每个元素做匹配，要求所有元素都满足判断，才返回true；
 *  noneMatch(Predicate<T> t) 对流每个元素做匹配，要求所有元素都不满足判断，才返回true；

查找

*  findAny(Predicate<T> t) 对流每个元素做匹配，找到一个满足判断的元素，返回这个元素；
 *  findFirst(Predicate<T> t)对流每个元素做匹配，找到"逻辑顺序下"的第一个满足判断的元素，返回这个元素；例如List转化成的流；

注意：**流的遍历在后台优化，保证最优查找（例如并行查找），因此返回的元素的顺序不确定**；其次，**返回值为Optional类**，它替代了所有的返回类型的对象，用来做非空判断和防止空指针；

**3. 规约**

是一个"**终端操作**"

*  reduce(T initValue,BiFunction<T,T,T> bf)从流的第一个元素开始，与指定的initValue做运算，返回一个结果，将这个结果作为下一次运算的初值，依次遍历整个流，最终所有的元素归化了一个T类型的结果；

应用：对流元素求和、求最大(小)值；eg：

Optional<Integer> sum = number.stream().reduce(0,(a,b)->(a+b));
    Optional<Integer> max = number.stream().reduce(Integer.MIN_VALUE,Math::min);

思考：**如果要求实现并行求和，怎么操作**？对共享变量sun加锁，对求和内容分块，将每一块的运行结果相加；**用流库只需要把stream()改成parallelStream()即可**；  
**注意**：并行流求和需要满足两个条件——传给reduce的Lambda不能改变状态(如实例变量)；操作满足结合律，即与顺序先后无关a+b=b+a;

\***流操作：无状态和有状态**

*  无状态：filter、map，对流的每一个元素分别操作，不依赖其他元素的操作结果；
 *  有状态：reduce-sum/max，依赖前面已有的累积的计算结果(状态累积)，而且这种状态是有界的；诸如sorted、distinct，需要直到先前的历史，例如排序需要将所有元素放入缓冲区后才能给输出流假如一个项目，这一操作的存储要求是无界的，当流很大（如无限流），就可能会出现问题，如质数流的反转，因为流是无限的，因此无法返回最大的质数；

**数值流**

int sum = myList.stream().reduce(Integer::sum);这一句存在问题：由于使用Integer::sum方法，**存在一个暗含的"装箱成本"，每个Integer元素都会自动拆箱成int再求和计算**；

怎么解决？**IntStream数值流——专门用来处理数值**；包含sum、max等实用方法；

int sum = myList.stream().mapToInt(Apple::getNum).sum();//其他常用的还有mapToDouble()和mapToLong();

mapToInt()区别于map()的地方在于applyAsInt(T t)，返回值不是普通的stream而是IntStream；

**构建流**

（1）由值创建，Stream<String> s = Stream.of("A","b");使用Stream.of()方法；  
（2）数组转成流，Fruit\_01\[\] f1 = new Fruit\_01\[\]\{\};Stream<Fruit\_01> sf = Arrays.stream(f1); 注：int\[\]数组会直接转成IntStream；  
（3）由文件生成流，eg：读取文件中的所有不重复的单词的总数量

@Test
        public void func_03() {
            String filePath = "file//a.txt";
            try (Stream<String> lines = Files.lines(Paths.get(filePath), Charset.defaultCharset())) {
                long uniqueWords = lines. flatMap(line -> Arrays.stream(line.split(""))).distinct().count();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

（4）创建无限流，通过：迭代iterate(T initvalue,Function<T,T> t)、生成generate(Supplier<T> s),因为流是无限长的，一般配合limit()使用；例如：

@Test
        public void func_02() {
            Stream.iterate(1, n -> 2 * n).limit(100).forEach(System.out::println);//2的幂
            Stream.iterate(new int[]{0, 1}, t -> new int[]{t[0], t[0] + t[1]}).map(n -> n[0]).limit(100).forEach(System.out::println);//斐波那契数列，每个元素为2个int构成的数组，map(n→n[0])打印第一个；
            Stream.generate(Math::random).limit(10).forEach(System.out::println);//打印10个[0,1]之间的随机数；
        }

**注**：创建流的**generate()内部的Lambda（Supplier）应该是"无状态"的**，这样在**并行流中才是安全的**！

**第 6 章**

用流收集数据-collect()，前面的所有中间操作得到了一个结果流，要对这个流的所有元素做某种处理，来展示我们需要的直观信息（结果可能需要一个值、一个字符串、一个List或者一个Map）；

1.  对**数字类型的汇总**  
    Collectors.summarize方法，得到对数字的汇总（数量、最大/小值、平均、求和），eg：

@Test
    public void func_02(){
    //reduce实现-求最值、求和
      int res_01 = Stream.of(20, 19, 0, 8, 30).reduce(Integer.MAX_VALUE, Math::min);
      int res_02 = Stream.of(20, 19, 0, 8, 30).reduce(Integer.MIN_VALUE, Math::max);
      int res_03 = Stream.of(20, 19, 0, 8, 30).reduce(0, (n1, n2) -> n1 + n2);
      System.out.println(res_01+" "+res_02+" "+res_03);
    //collector-**summarize**()方法
      IntSummaryStatistics summary = Stream.of(20, 19, 0, 8, 30).collect(Collectors.summarizingInt((n)->(n)));
      System.out.println(summary.getMin()+" "+summary.getMax()+" "+summary.getSum());
    }

**2. 得到字符串**  
Collectors.joining方法合并Stream<String>中的元素，eg：

@Test
    public void func_01(){
      Stream<String> s = Stream.of("apple", "orange", "pineapple");
      String res = s.collect(**Collectors.joining**(", "));
      System.out.println(res);
    }

**3. 分组**  
**分组的目的是对之前处理得到的一个结果流，做一个"分类"，按照某种"分类规则"（如流元素的一个属性name），对流分类，放入一个map，map的key为属性，value为一个List流元素的集合；**

@Test
    public void func_03() {//Collectors.groupingBy的用法
      List<Dish_tc> list = new ArrayList<>();
      list.add(new Dish_tc(3, "S"));
      list.add(new Dish_tc(1, "A"));
      list.add(new Dish_tc(2, "D"));
      list.add(new Dish_tc(3, "X"));
      list.add(new Dish_tc(2, "Y"));
      list.add(new Dish_tc(1, "Z"));
    
    //**(1)按照value属性分组**
      System.out.println(list.stream().collect(Collectors.groupingBy(Dish_tc::getValue)));
    
    //**(2)对value进一步划分（value属性太细了，现在要求只分2类）**
      System.out.println(list.stream().collect(Collectors.groupingBy(
        d -> {
        if (d.getValue() > 2) return ">2";
        else return "<=2";
        }
      )));
    
    //**(3)多级分组，对map的value的List集合进一步分组**
      Map<Integer, Map<String, List<Dish_tc>>> mmp = list.stream().collect(Collectors.groupingBy(Dish_tc::getValue, Collectors.groupingBy(Dish_tc::getName)));
      System.out.println(mmp);
    
    //**(4)不需要组内（每个List）的具体元素信息，只需要统计个数；**
      System.out.println(list.stream().collect(Collectors.groupingBy(Dish_tc::getValue, Collectors.counting())));
    }
    
    class Dish_tc {
      public int getValue() {
        return value;
      }
      int value;
    
      public String getName() {
        return name;
      }
      String name;
    
      Dish_tc(int value, String name) {
        this.value = value;
        this.name = name;
      }
    
      boolean isDelicoous() {return name.contains("D") || name.contains("Z");}//"是否好吃"
    
      public String toString() {
        return this.value + "-" + this.name + ";";
      }
    }

**4. 分区 Collectors.patitioningBy(Predicate p)**

分区和分组很像，类似上面的(2)的代码，对Map有个特定限制——就是map的key类型为boolean，也就是说分成了两类；

@Test
        public void func_03() {
            Map<boolean, List<Dish_tc> mp = list.stream().collect(Collectors.patitioningBy(Dish_tc::isDelicious)); //根据"是否好吃"分成两类
    
            //针对上面的(2)的自定义分组，现在仅仅分两组true/false，即Map的key为boolean，使用partitioning()方法，该方法可以嵌套
            System.out.println(list.stream().collect(Collectors.partitioningBy(Dish_tc::isDelicoous))); //根据"是否好吃"分成true/false两类
            System.out.println(list.stream().collect(Collectors.partitioningBy(Dish_tc::isDelicoous, Collectors.partitioningBy((d) -> d.getValue() > 2)))); //可嵌套
            System.out.println(list.stream().collect(Collectors.partitioningBy(Dish_tc::isDelicoous, Collectors.groupingBy(Dish_tc::getName)))); //与groupingBy可嵌套
        }

[c8d99f6079ff41f2d3414ae1d0f2d0c1.png]: https://img-blog.csdnimg.cn/img_convert/c8d99f6079ff41f2d3414ae1d0f2d0c1.png
[5d04e8437f6712c75696948e6fa21249.png]: https://img-blog.csdnimg.cn/img_convert/5d04e8437f6712c75696948e6fa21249.png
[Java_final -]: https://www.jianshu.com/p/71d09dd5db8c
[Ruby]: https://www.jianshu.com/p/f55b11a4cec2