- Java8中新增了一个默认的方法。 这个默认方法的目的是在接口中可以实现方法，而且不强制要求实现类去实现这个方法，定义也很简单只需要在方法的前面加上default即可：
public interface MyInterface {
void add(int a ,int b);
default int sub(int a ,int b){
return a - b;
}
}
- 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。 有大数据资料赠送哟，因为我最近也在学习大数据！
