Java中的Lambda表达式

1. Java8中新增了一个默认的方法。 这个默认方法的目的是在接口中可以实现方法，而且不强制要求实现类去实现这个方法，定义也很简单只需要在方法的前面加上default即可：

public interface MyInterface {
    void add(int a ,int b);

    default  int sub(int a ,int b){
        return  a - b;
    }
}

2. Lambda表达式： Lambda表达式是也是在Java中新增的，现在才看这个东西，实在是有点惭愧。Lambda表达式本质是语法糖，由编译器来推断并帮你转换为常规的代码，因此你可以用一行代码或者更少的代码来实现相同的功能，如下面的例子：

        List<String> list = Arrays.asList("hello", "world");
        list.forEach(new Consumer<String>() {
            public void accept(String s) {
                System.out.println(s);
            }
        });
        
        //Lanmbda表达式
        list.forEach(item -> System.out.println(item));

Lambda表达式是由参数列表，箭头和函数体组成，函数体可以是一个表达式，也可以是一个语句块。
表达式会被执行然后返回执行结果，表达式适合小型的计算，他不需要使用return，使句子更加简洁，语句块中返回值可以用return，跟正常的method体没啥太大区别。

其中参数列表是可以被编译器自行推倒的，如果可以从目标类型中推导出参数的类型，那我们就没有必要去写这个类型，比如

Comparator<String> comparator = (String s1, String s2) -> s1.compareTo(s2);

我们完全可以写成：

 Comparator<String> comparator = ( s1,  s2) -> s1.compareTo(s2);

同理但只有一个参数的时候，甚至我们可以把括号给去掉

Lambda表达式既然是一个语法糖，那么他的本质是什么呢？
其实是Java8中的函数式接口 Function Interface。
可以看下一下Consumer 这个接口的源码：

@FunctionalInterface
public interface Consumer<T>{
        void accept(T t);
        default Consumer<T> andThen(Consumer<? super T> after) {
           Objects.requireNonNull(after);
          return (T t) -> { accept(t); after.accept(t); 
        };
    }
}

这个接口上有一个注解FunctionalInterface，这个是Java8中新定义的一个注解，主要就是用来Lambda表达式，所以很多java8中很多接口上都用到了这个接口，所以所有的用到这个注解的接口都可以用Lambda表达式来替代，但是这个接口不是必须的，如果一个接口符合函数式接口的定义 ，加不加该注解都没有影响，加上该注解能够更好的让编译器进行检查，如果编写的接口不是函数式接口，那么加上这个注解会报错。
那么什么符合函数式接口的定义呢？ 接口中必须只有一个抽象方法，其他的重写的Object中的public方法和default方法不算，比如equeas，toString等，接口中允许有静态方法。
所以我们可以自定义一个，比如：

public interface OnClickListener {

    void onClick();
}

public class SelfView {

    private OnClickListener listener;

    public OnClickListener getListener() {
        return listener;
    }

    public void setListener(OnClickListener listener) {
        this.listener = listener;
        listener.onClick();
    }
}

然后在main方法中调用：

    public static void main(String[] args) {

        SelfView view = new SelfView();
        view.setListener(() -> System.out.println("sdf"));
    }
    
    结果： sdf

Java8中那些地方可以使用Lambda表达式呢？这些接口在原来的基础上改的：

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.beans.PropertyChangeListener

新增了一个java.util.function， 它里面包含了一些常用的接口：

Predicate<T>——接收T对象并返回boolean
Consumer<T>——接收T对象，不返回值
Function<T>——接收T对象，返回R对象
Supplier<T>——提供T对象（例如工厂），不接收值
UnaryOperator<T>——接收T对象，返回T对象
BinaryOperator<T>——接收两个T对象，返回T对象
。。。。。
还有一些针对原始类型的接口，比如ToDoubleFunction<T> 等等。

其中在集合中提供一个stream的接口，使用起来简直不要不要的。
比如过滤：

    list.stream()
        .filter(e -> e.getLastName().contains("Li"))
        .forEach(e-> System.out.println(e.getLastName()));

stream里面还有很多方法，比如说求和，最大值，最小值等等

在Lambda表达式中还有另外一个知识点叫做方法引用：
方法引用分为： 构造方法的引用，静态方法的应用，类方法的应用，但是必须都在函数表达式中引用，引用网上很多人用的例子：

public class Car {

    public Car(Supplier<Car> supplier) {
        supplier.get();
    }

    // 通过Supplier获取Car实例
      public static Car create(Supplier<Car> supplier) {
                return supplier.get();
      }

    public static void collide(final Car car) {
        System.out.println("Collide " + car.toString());
    }

    public void follow(final Car car) {
        System.out.println("Following car " + car.toString());
    }

    public void repair() {
        System.out.println("Repaired car " + this.toString());
    }
}

其中Supplier也是一个函数式接口：

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

所以我们可以这样写： Car.create(()->new Car());

因为构造方法都是不带构造参数的，所以有一个更简洁的写法：Car.create(Car::new);
这就是构造方法的引用。

静态方法的应用： 语法是Class::static_method

        Car car = Car.create(Car::new);
        List<Car> cars = Arrays.asList(car);
        cars.forEach(Car::collide);

第三种是类的成员方法：

     cars.forEach(Car::repair);

带有参数的成员方法的引用：

        Car foll = Car.create(Car::new);
        cars.forEach(foll::follow);

欢迎关注我的公众号： manong_xiaodong。 有大数据资料赠送哟，因为我最近也在学习大数据！