lambda是函数式编程（FP，functional program），在java8中引入，而C#很早之前就有了。在java中lambda表达式是'->',在C#中是‘=>’。

杜甫说：射人先射马，擒贼先擒王。学习一个库要学习它的入口类。lambda的入口类是Stream，一看Stream中的函数就会发现Function，Predicate等lambda元素。

一.几个概念

    函数式接口 Functional Interface，除了static和default类型的方法外，只有一个函数的接口。以前，接口中的一切方法都是public的，现在接口中可以包含default类型的实现方法了。java中没有函数指针的概念，C#中有delegate委托相当于函数指针，但java也是有办法的，用一个类，类里面有一个函数，这个类就相当于函数指针。这么整实现简单，理解简单，但是代码比较冗长。

　 谓词 Predicate， 简单来说，谓词就是条件。正规来说，谓词就是一个函数boolean f（x1，x2...），表示变量x1,x2...是否满足条件f。在java中谓词的定义就是一个函数式接口。

    函数（映射） Function，将一种类型的对象映射为另一种或同种类型的对象，它就是一个函数ObjectA f（ObjectB）。在java中映射的定义也是一个函数式接口。

@FunctionalInterfacepublic interface Function
     
       {    R apply(T t);    default 
      
        Function
       
         compose(Function
         before) {        Objects.requireNonNull(before);        return (V v) -> apply(before.apply(v));    }     default 
        
          Function
         
           andThen(Function
           after) {        Objects.requireNonNull(after);        return (T t) -> after.apply(apply(t));    }     static 
          
            Function
           
             identity() { return t -> t; }}
           
          
         
        
       
      
     

可见，除了apply()函数以外，其余default方法在外部都是不可见的。所以定义函数式接口的时候需要把其他函数声明称static或者default类型的。

Optional这个值表示一个对象，这个对象可能为空也可能不为空，对于它可以产生许多行为：

如果它是null，该怎么做orElse()和orElseGet()

如果不为null，该怎么做ifPresent()

判断是否为null，isPresent()

这个类看上去十分鸡肋，但用处十分广泛

package aaa;import java.util.NoSuchElementException;import java.util.Optional;public class OptionalDemo {           public static void main(String[] args) {        //创建Optional实例，也可以通过方法返回值得到。        Optional
      
        name = Optional.of("Sanaulla");             //创建没有值的Optional实例，例如值为'null'        Optional
       
      

 

二.lambda表达式

有两个作用

* 作为函数指针

* 替代匿名内部类，替代函数式接口（FunctionalInterface）

lambda不是语法糖，它在内部实现上也跟匿名内部类不同，匿名内部类需要进行类文件加载，而lambda表达式不用，所以lambda表达式效率比匿名内部类高。

三种用法

用'(x1,x2,x3)'表示传入参数

如果无参写作’()‘

参数类型可以指明，也可以不指明,java会根据后半部分函数形参自动推断出来。

List
     
       a = Arrays.asList("we i di ao is great".split(" "));        a.forEach((s) -> System.out.println(s));// 表达式        a.forEach((String s) -> {            System.out.println(s);        });// 语句块        a.forEach(System.out::println);// 函数
     

方法引用

object::fun()

className::fun()静态方法引用

className::new  构造函数引用

 

public class LambdaIntro {    // functional interface 函数式接口    public static interface ItemWithIndexVisitor
     
       {        public void visit(E item, int index);    }    public static 
      
        void eachWithIndex(List
       
         list,            ItemWithIndexVisitor
        
          visitor) {        for (int i = 0; i < list.size(); i++) {            visitor.visit(list.get(i), i);        }    }    // 一个普通函数，用作函数指针    public static 
         
           void printItem(E value, int index) {        String output = String.format("%d -> %s", index, value.toString());        System.out.println(output);    }    public static void main(String[] args) {        List
          
            list = Arrays.asList("A", "B", "C"); // 第一种方式 eachWithIndex(list, (value, index) -> { String output = String.format("%d -> %s", index, value); System.out.println(output); }); // 第二种方式 eachWithIndex(list, LambdaIntro::printItem); }}
          
         
        
       
      
     

 

三.使用Stream

创建Stream的两种方式

* Stream接口的工厂方法

* 集合框架的stream()函数

首先来了解使用Stream接口来创建Stream，可以创建三种流：普通枚举流，产生器，迭代器。

//of：通过枚举方式创建流        Stream
     
       one = Stream.of(1, 2, 3);        //流是可以拼接的，从而产生新流        Stream
      
        two = Stream.concat(one, Stream.of(4, 5, 6));        two.forEach(System.out::println);        //逐个加入，那就用Builder构建器来实现        Builder
       
         builder = Stream.builder();        Stream
        
          three = builder.add(3).add(4).build();        three.forEach((s) -> System.out.println(s));        //产生器流generator        Random random = new Random();        Stream
         
           four = Stream.generate(() -> random.nextInt());        four.limit(10).forEach(System.out::println);        //迭代器iterator，UnaryOperator一元运算符可以通过lambda表达式来创建        Stream
          
           five=Stream.iterate(2, new UnaryOperator
           
            () { @Override public Integer apply(Integer t) { return t = (t * 5 + 7) % 13; } }); five.limit(10).forEach(System.out::println);
           
          
         
        
       
      
     

注意产生器generator和迭代器iterator是无限输出的，可以用limit来约束之。

集合框架都继承了Collection接口，而Collection接口就有一个stream()函数。所以剩下的任务就是如何利用流的强大特性来写出优雅的代码来。

要想深刻的了解Stream的一些函数，那就先不要使用lambda表达式，一旦了解它的普通实现，很容易改写成lambda的形式。

流Stream中的函数明显分为两类，一类返回值还是Stream，可以继续用流来处理，另一类返回值不是Stream，不能再用流中函数处理了。

Stream filter(Predicate)删除掉流中不满足条件的元素并返回新的Stream

Stream map(Function)映射，把流中的元素映射一下变成一个新流，还有mapToInt(),mapToLong(),mapToDouble()等函数，它们终究还是映射，只是映射结果更单一。map是一对一映射，flatMap是一对多映射。把一个元素映射成多个元素

Arrays.asList(1, 2, 3).stream()                .flatMap(new Function
     
      >() {                    @Override                    public Stream
      
        apply(Integer t) {                        return Arrays.asList(t, t + 10, t + 100).stream();                    }                }).forEach(System.out::println);
      
     

输出为1 11 101 2 12 102 3 13 103   中间我省略了换行符 

distinct()去除流中重复元素

sorted()和sorted(Comparator cmp)对流中元素排序

peek()弹出一个元素

Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3)                .peek(e -> System.out.println("Filtered value: " + e))                .map(String::toUpperCase)                .peek(e -> System.out.println("Mapped value: " + e))                .collect(Collectors.toList());

执行结果

Filtered value: threeMapped value: THREEFiltered value: fourMapped value: FOUR

limit(int cnt)只返回cnt个元素，skip(int cnt)跳过cnt个元素。

forEach(Consumer consumer)对于每一个元素都执行某种操作

reduce()将多个值映射为一个值，实现多对一映射

Stream.of("one", "two", "three", "four")                .reduce(new BinaryOperator
     
      () {                    @Override                    public String apply(String t, String u) {                        System.out.println(t+":"+u);                        return t + "," + u;                    }                }).ifPresent(System.out::println);
     

输出为

one:twoone,two:threeone,two,three:fourone,two,three,four

可见，apply(t,u)函数中的t表示当前总量，u表示当前元素。

reduce(T identity,BinaryOperator<T>f)表示带初始值的reduce，比如求和函数，如果identity=9，表示一开始sum=9，此函数返回具体的对象。

String s = Stream.of("one", "two", "three", "four").reduce("baga",                new BinaryOperator
     
      () {                    @Override                    public String apply(String t, String u) {                        return t +","+ u;                    }                });        System.out.println(s);
     

输出：

baga,one,two,three,four

collect()

Map
     
      >> peopleByStateAndCity         = personStream.collect(Collectors.groupingBy(Person::getState,                                                      Collectors.groupingBy(Person::getCity)));
     

String s=Stream.of("one", "two", "three", "four")                .collect(Collectors.joining(","));        System.out.println(s);

输出one,two,three,four

Collectors包含许多有用的静态方法

聚集函数min(),max(),count()很像sql中的聚集函数

匹配函数allMatch(Predicate p)，anyMatch(Predicate p)，noneMath(Predicate p)流中全部匹配，部分匹配，完全不匹配，返回布尔值