JAVA8新特性（一）

• default拓展方法

java8为接口声明添加非抽象方法的实现，也成为拓展方法。

public interface Formula {
    void doSomething();

    default void before() {
        System.out.println("我是拓展方法");
    }
}

public class FormulaService implements Formula {

    @Override
    public void doSomething() {
        before();
        System.out.println("我是override方法");
    }
}

• Lambda表达式

java8引入函数式编程，Lambda则是函数式编程的基础。

List<String> list = Arrays.asList("a", "b", "c");

// java8之前
Collections.sort(list, new Comparator<String>(){
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

// lambda
Collections.sort(list, (String o1, String o2) -> {
            return o2.compareTo(o1);
});

// 简洁lambda
Collections.sort(list, (String o1, String o2) ->  o2.compareTo(o1));

// 更简洁lambda
Collections.sort(list, (o1, o2) ->  o2.compareTo(o1));

• 函数式接口

一个函数式接口有且只能有一个抽象方法申明，其中该注意的是 @FunctionalInterface 注解，此时如果在接口中定义了第二个抽象方法，编译器将会抛出异常。当然如果不加该注解也不是不行，如果接口中有多个抽象方法，而你又使用了lambda表达式，则在调用处会抛出异常。

@FunctionalInterface
public interface Formula<F,T>{
    T convert(F var1);
}

Formula<String,Integer> function = (var1 -> Integer.valueOf(var1));
Integer var2 = function.convert("1000");

• 方法和构造函数引用

方法引用的标准语法是 类名:方法名

类型	示例
引用静态方法	targetClass :: staticMethodName
引用某个对象的实例方法	targetClass :: instanceMethodName
引用某个类型的任意对象的实例方法	targetType :: methodName
引用构造方法	className :: new

引用静态方法

Formula<String,Integer> function = (Integer::valueOf);
Integer var2 = function.convert("1000");

引用某个类型的任意对象的实例方法

public static void main(String[] args) {
   String[] array = {"贱明", "学友"};
   Arrays.sort(array, String::compareTo);
}

引用构造方法

// 定义工厂
interface PersonFactory<P extends Person>{
    P create(String name);
}
// Person类的构造方法
public Person(String name) {
    this.name = name;
}
// 创建
PersonFactory<Person> factory = Person::new;
factory.create("贱明");

• Lambda的范围

lambda可以访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。

访问成员变量

public void doSomething(){
    final String p1 = "贱明";
    final String p2 = "学友";
    Formula function = (person1, person2) -> p1.compareTo(p2);
}

与java8以下版本不同的是，p1 p2你可以不修饰成final 也不会报错，但是如果你想修改他们，编译器则会告诉你这是不被允许的。

访问成员变量和静态变量

public void doSomething(){;
   Formula function = (person1, person2) ->{
       dehua = "贱明";
       xueyou="学友";
       return dehua.compareTo(xueyou);
   };
}

• 内置函数式接口

java8 api中提供了很多内置函数式接口，而且有些接口其实在Google Guava中已经实现了，很大程度的降低了程序员的工作负担。

Predicates

Predicate是一个布尔类型的函数，该函数只有一个输入参数，他包含了多种默认实现。

public static void main(String[] args) {
   Predicate<String> predicate = (s) -> s.contains("贱明");
   String var1 = "牛贱明";

   predicate.test(var1);              // true
   predicate.negate().test(var1);     // false

   Predicate<Boolean> nonNull = Objects::nonNull;
   Predicate<Boolean> isNull = Objects::isNull;

   Predicate<String> isEmpty = String::isEmpty;
   Predicate<String> isNotEmpty = isEmpty.negate();

   isNotEmpty.and(isEmpty).test(var1);
}

Functions

Function接口接收一个参数，并返回单一的结果。默认方法可以将多个函数串在一起

public static void main(String[] args) {
   Function<String, Integer> toInteger = Integer::valueOf;
   Function<String, String> backToString = toInteger.andThen(String::valueOf);

   System.out.println(toInteger.apply("123"));
   System.out.println(backToString.apply("123"));
}

Suppliers

Supplier接口产生一个给定类型的结果。与Function不同的是，Supplier没有输入参数。

Supplier<Person> personSupplier = Person::new;
Person p = personSupplier.get();   // new Person

Consumers

Consumer代表了在一个输入参数上需要进行的操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.getName());
greeter.accept(new Person("贱明"));

Comparators

Comparator接口在早期的Java版本中非常著名。Java 8 为这个接口添加了不同的默认方法。

Comparator<Person> comparator = (p1, p2) -> p1.getName().compareTo(p2.getName());

Person p1 = new Person("贱明");
Person p2 = new Person("学友");

System.out.println(comparator.compare(p1, p2));             // > 1105
System.out.println(comparator.reversed().compare(p1, p2));  // < -1105

Optionals

Optional不是一个函数式接口，而是一个精巧的工具接口，用来防止NullPointerException产生。

Optional是一个简单的值容器，这个值可以是null，也可以是non-null。考虑到一个方法可能会返回一个non-null的值，也可能返回一个空值。为了不直接返回null，我们在Java 8中就返回一个Optional。

Optional<String> optional = Optional.of("贱明");

System.out.println(optional.isPresent()); // true
System.out.println(optional.get()); // 贱明
System.out.println(optional.orElse("学友")); // 贱明    

optional.ifPresent((s) -> System.out.println(s.charAt(0)));