java8实战二------lambda表达式和函数式接口，简单就好

一、Lambda

可以把Lambda表达式理解为简洁地i表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还是一个可以抛出的异常列表。

听上去，跟我们用的匿名类，匿名方法什么的很像。我们继续看看把。

第一篇，我们做的事分苹果，这次我们给苹果根据重量来做个Comparator吧。

先来以前的：

  Comparator<Apple> byWeight=new Comparator<Apple> () {
             @Override
             public int compare(Apple o1, Apple o2) {
                 return o1.getWeight ().compareTo (o2.getWeight ());
             }
         };

用了lambda：

  Comparator<Apple> byWeight=(Apple a1,Apple a2)->a1.getWeight ().compareTo (a2.getWeight ());

是不是很简单。简单讲一下lambda的格式，由lambda参数、箭头、lambda主体三部分组成；

其中lambda参数也可以不用写类型，它会根据上下文自己判断类型，后面有例子出现。

而lambda主题如果像以上表达式只有一句的话，可以不叫{},但有多条语句的话必须加{}。

二、函数式接口

 public interface Pridicate<T>{
        boolean test(T t);
 }

类似上面的接口一样，只定义一个方法的接口，我们称之为函数式接口。Runable，Comparator都是一个函数式接口。当然，并不是严格意义上的只有一个方法，还可以有default修饰的默认方法。

函数式接口的抽象方法的签名基本上就是Lambda表达式的签名，称之为函数描述符。比如，Runable的run（）方法，什么也不接收，什么也不返回，Runable可以作为run方法的签名。函数描述符为（）->void 。给个栗子！

 public class Demo6 {
     public static void main(String[] args) {
         //old
        process (new Runnable () {
            @Override
            public void run() {
                System.out.println ("This is old");
            }
        });
        //new
         process (()-> System.out.println ("This is new "));
     }
     public static void process(Runnable r){
         r.run ();
     }
 }

我们知道process（）方法接收的是一个函数式接口，所以我们直接可以用lambda表达式来表示这个函数式接口，（）表示不接受参数，lambda主体不返回参数，

完成的功能和上面匿名是一样的。我再来个反例！

 Predicate<Apple> predicate=(Apple a)->a.getWeight ();
 //Bad return type in lambda expression: Integer cannot be converted to boolean

Apple的getWeight是个Integer返回类型，而，我们需要的是一个boolean类型，所以报错。这里解释一下Predicate等类。

（1）Predicate<T>定义了一个抽象方法test（），返回boolean值。后面可以用来做filter的条件。

像上面的反例，加入我在Apple加一个方法

  public boolean islight(){
         if(this.getWeight ()>4){
             return false;
         }
         return true;
     }

我们就可以写  Predicate<Apple> predicate=(Apple a)->a.islight (); 这样就不会报错。

java8中常用的函数式接口：

所谓原始类型转化，其实很容易理解，像IntToDoubleFunction: IntToDoubleFunction i=(int s)->s*1.0; 对传入的s返回double。不用声明泛型，根据字面意思

int转double。

此外，lambda其实能根据上下文推断传入参数的类型： IntToDoubleFunction i=s->s*1.0; 因为IntToDoubleFunction的函数描述符式T->R,它自动判断s是int。

三、方法引用

上文中我们设计了一个Predicate<Apple>来区分轻重的苹果，我们先来看看方法引用。

         Predicate<Apple> predicate=(Apple a)->a.islight ();
         //方法引用
         Predicate<Apple> predicate1=Apple::islight;

我们看看，Apple的islight（）方法是传入一个Apple，返回一个boolean。函数描述符为Apple->boolean。我们先写个自己的Predicate。

 class MyPredicate implements Predicate<Apple>{
     @Override
     public boolean test(Apple apple) {
         if (apple.islight ()){
             return true;
         }
         return false;
     }
 }

使用函数式接口的进阶顺序是：（1）自己写实现类，（2） Predicate<Apple> predicate=a->a.islight ();

(3) Predicate<Apple> predicate1=Apple::islight;

(2)和（3）都是直接用lambda表达式表示Predicate。而（3）中用方法引用，使得代码，更加简洁。

我们应该注意：我们调的方法是Apple的islight（），函数描述符要符合函数式接口的函数描述符。合理的使用能使你的代码更加简洁。

这次，就写这些了。

陆续更新。