Java8：函数式编程、Stream

函数式编程：

什么是函数式接口？
        接口中有且只有一个抽象方法。当然默认方法，静态方法，私有方法可以包含。
什么是语法糖？
        更加方便，原理不变的语法。
函数式接口的定义：
        一个接口中只有一个抽象方法即可。
        例如：
@FunctionalInterface    //标识这个接口是函数式接口。
修饰符 interface 接口名称{
 public abstatic 返回值 方法名称(参数列表);  // public abstatic 可以省略。
}
lambda表达式相对于匿名内部类的优势？
     匿名内部类。（需要加载class文件）。
     lambda表达式  ()->{}  （延迟加载，并且不会加载class文件）。
     lambad表示式可以实现传递方法的效果。
lambda如何简写？
        由于lambda表达式可推导，所以参数类型是可以省略的。如果方法体中只有一行代码：后面的大括号和分号也是可以省略的。
什么是Lambda的延迟加载的特性？
        有些代码执行之后的结果不一定会使用，会造成性能的浪费。 lambda中的代码只有运行时才执行，可以利用lambda的延迟加载特性优化代码。
        将lambda表达式当作参数传递的时候，传递过去的只是lambda表达式。只有运行该表达式的时候，相应的代码才会被执行。
常用的函数式接口：
        常用的函数式接口放在：java.util.funcation包下。
        1：java.util.funcation.Supplier<T>接口
                 T get();    // 生产一个指定泛型的数据
                该接口是一个生产型的接口 。
        2：java.util.funcation.Consumer<T> 接口
                void accept(T t);   // 消费一个指定泛型的数据。
                该接口是一个消费型的接口
                Consumer接口中有些默认方法：
                        2.1：Consumer<T> andThen(Consumer<T>)  // 作用是连接两个Conusmer接口，依次消费两次。
            Consumer<String> con1;
            Consumer<String> con2;
            con1.accept("str");
            con2.accept("str");
          等同于：
            con1.andThen(con2).accept("str");
                                   上面这个链式语句，con1先消费，con2后消费。

Stream:

什么是Stream流？
    “Stream流”其实时一个集合元素操作的函数模型， 它并不是集合，也不是数据结构，其本身并不存储任何元素或者地址。
    Java中的Stream流不会存储元素，而是按需计算。
Stream能干什么？
    Stream 可以简化集合、数组操作。关注的是要做什么，不是怎么做。
为什么要用Stream流？
    因为数组集合的操作有弊端：例如：
        需求：操作集合中的数据。 代码：需要额外的遍历，然后操作数据。存在的问题：必须要额外的使用迭代器。
Stream使用案例：
// Stream流案例
List<String> nams = new ArrayList<>();
nams.add("张三");
nams.add("李四");
// 利用Stream流， 先过滤，再输出。
nams.stream().filter(n->n.length() == 3)
        .filter(n->n.contains("张"))
        .forEach(n-> System.out.println(n));
链式的调用Stream方法是在干什么？
        是在 “拼接流式模型”（比喻：构建一个处理集合的生产线，集合要依次通过各种工作站）
        就像上面代码中 filter方法只是建立模型， 最后的forEach执行时才会真正操作集合。得益于lambad的延迟加载。
Stream对集合的操作有两个基本特性：
    1、PipeLining:中间操作都会返回流本身，这样多个操作就会串成一个管道。这样做可以对操作进行优化。
    2、内部迭代：流可以直接调用遍历方法。达到遍历的效果。（不用通过迭代器）
使用Stream的一般流程为：
    1、获取一个数据源（数组或者集合）
    2、数据转换（将数据源变成Stream流）
    3、流式处理Stream流对象。（构建Stream流模型）
Stream的方法分类？
    1、延迟方法：返回类型依然是Stream类型，可以进行链式调用。
    2、终结方法：链式调用的最后一步骤。例如：forEach、count
Stream常用方法？
    1、forEach：void forEach(Consumer<? super T> action);
          用于遍历消费，Consumer是函数式消费接口。
    2、filter：stream<T> filter(Predicate<? super T> predicate)
          用于筛选元素，Predicate用于判断的函数式接口。
    3、map：<R> Stream<R> map(Funcation<? super T ,? extends R> mapper);
          用于转换元素。
    4、long count();
          终结方法，元素的数量。
    5、limit : Stream<T> limit (long maxSize)
          截取流，例如：limit(5)  截取5个元素，并返回新流。
    6：skip : Stream<T>skip (long maxSize)
           跳过后截取流，例如：skip(5) 截取[6 ~ 最后一个]形成的流。
    7：concat 静态方法，用于合并两个流。
           将两个流合并成为一个流：例如：streamC = Stream.concat(streamA , streamB)

原文地址：https://www.cnblogs.com/Xmingzi/p/12601130.html