Java8新特性

1.接口的默认方法和静态方法

在Java8之前，接口中只能包含抽象方法。那么这有什么样弊端呢？比如，想再Collection接口中添加一个spliterator抽象方法，那么也就意味着之前所有实现Collection接口的实现类，都要重新实现spliterator这个方法才行。而接口的默认方法就是为了解决接口的修改与接口实现类不兼容的问题，作为代码向前兼容的一个方法。

那么如何在接口中定义一个默认方法呢？来看下JDK中Collection中如何定义spliterator方法的：

default Spliterator spliterator() {
    return Spliterators.spliterator(this, 0);
}

可以看到定义接口的默认方法是通过default关键字。因此，在Java8中接口能够包含抽象方法外还能够包含若干个默认方法（即有完整逻辑的实例方法）。

public interface IAnimal {
    default void breath(){
        System.out.println("breath!");
    };
}

public class DefaultMethodTest implements IAnimal {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.breath();
    }

}
//输出结果为：breath!

可以看出IAnimal接口中有由default定义的默认方法后，那么其实现类DefaultMethodTest也同样能够拥有实例方法breath。但是如果一个类继承多个接口，多个接口中有相同的方法就会产生冲突该如何解决？实际上默认方法的改进，使得java类能够拥有类似多继承的能力，即一个对象实例，将拥有多个接口的实例方法，自然而然也会存在方法重复冲突的问题。

下面拿一个例子做说明:

public interface IDonkey{
    default void run() {
        System.out.println("IDonkey run");
    }
}

public interface IHorse {

    default void run(){
        System.out.println("Horse run");
    }

}

public class DefaultMethodTest implements IDonkey,IHorse {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.breath();
    }
}

定义两个接口：IDonkey和IHorse，这两个接口中都有相同的run方法。DefaultMethodTest实现了这两个接口，由于这两个接口有相同的方法，因此就会产生冲突，不知道以哪个接口中的run方法为准，编译会出错：inherits unrelated defaults for run.....

解决方法

针对由默认方法引起的方法冲突问题，只有通过重写冲突方法，并方法绑定的方式，指定以哪个接口中的默认方法为准。

public class DefaultMethodTest implements IAnimal,IDonkey,IHorse {
    public static void main(String[] args) {
        DefaultMethodTest defaultMethod = new DefaultMethodTest();
        defaultMethod.run();
    }

    @Override
    public void run() {
        IHorse.super.run();
    }
}

DefaultMethodTest重写了run方法，并通过 IHorse.super.run();指定以IHorse中的run方法为准。

静态方法

java8中还有一个特性是,接口中还可以声明静态方法:

public interface IAnimal {
    default void breath(){
        System.out.println("breath!");
    }
    static void run(){}
}

2.函数式接口FunctionInterface与Lambda表达式

函数式接口

Java8最大的变化是引入了函数式思想，也就是说函数可以作为另一个函数的参数。函数式接口，要求接口中有且仅有一个抽象方法，因此经常使用的Runnable，Callable接口就是典型的函数式接口。可以使用@FunctionalInterface注解，声明一个接口是函数式接口。如果一个接口满足函数式接口的定义，会默认转换成函数式接口。但是，最好是使用@FunctionalInterface注解显式声明。这是因为函数式接口比较脆弱，如果开发人员无意间新增了其他方法，就破坏了函数式接口的要求，如果使用注解@FunctionalInterface，开发人员就会知道当前接口是函数式接口，就不会无意间破坏该接口。下面举一个例子：

@java.lang.FunctionalInterface
public interface FunctionalInterface {
    void handle();
}

该接口只有一个抽象方法，并且使用注解显式声明。但是，函数式接口要求只有一个抽象方法却可以拥有若干个默认方法的（实例方法），比如下例：

@java.lang.FunctionalInterface
public interface FunctionalInterface {
    void handle();

    default void run() {
        System.out.println("run");
    }
}

该接口中，除了有抽象方法handle外，还有默认方法（实例方法）run。另外，任何被Object实现的方法都不能当做是抽象方法。

Lambada表达式

lambda表达式是函数式编程的核心，lambda表达式即匿名函数，是一段没有函数名的函数体，可以作为参数直接传递给相关的调用者。lambda表达式极大的增加了Java语言的表达能力。lambda的语法结构为：

(parameters) -> expression
或
(parameters) ->{ statements; }

完整示例为

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

另外，lambda还可以访问外部局部变量，如下例所示：

int adder = 5;
Arrays.asList(1, 2, 3, 4, 5).forEach(e -> System.out.println(e + adder));

实际上在lambda中访问类的成员变量或者局部变量时，会隐式转换成final类型变量，所以上例实际上等价于：

final int adder = 5;
Arrays.asList(1, 2, 3, 4, 5).forEach(e -> System.out.println(e + adder));

3.方法引用

方法引用是为了进一步简化lambda表达式，通过类名或者实例名与方法名的组合来直接访问到类或者实例已经存在的方法或者构造方法。方法引用使用::来定义，::的前半部分表示类名或者实例名，后半部分表示方法名，如果是构造方法就使用NEW来表示。

方法引用在Java8中使用方式相当灵活，总的来说，一共有以下几种形式：

• 静态方法引用：ClassName::methodName;
• 实例上的实例方法引用：instanceName::methodName;
• 超类上的实例方法引用：supper::methodName;
• 类的实例方法引用：ClassName:methodName;
• 构造方法引用Class:new;
• 数组构造方法引用::TypeName[]::new

例子:

public class MethodReferenceTest {

    public static void main(String[] args) {
        ArrayList cars = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Car car = Car.create(Car::new);
            cars.add(car);
        }
        cars.forEach(Car::showCar);

    }

    @FunctionalInterface
    interface Factory {
        T create();
    }

    static class Car {
        public void showCar() {
            System.out.println(this.toString());
        }

        public static Car create(Factory factory) {
            return factory.create();
        }
    }
}


输出结果：

learn.MethodReferenceTest$Car@769c9116
learn.MethodReferenceTest$Car@6aceb1a5
learn.MethodReferenceTest$Car@2d6d8735
learn.MethodReferenceTest$Car@ba4d54
learn.MethodReferenceTest$Car@12bc6874

在上面的例子中使用了Car::new，即通过构造方法的方法引用的方式进一步简化了lambda的表达式，Car::showCar，即表示实例方法引用。

4.Stream

Java8中有一种新的数据处理方式，那就是流Stream，结合lambda表达式能够更加简洁高效的处理数据。Stream使用一种类似于SQL语句从数据库查询数据的直观方式，对数据进行如筛选、排序以及聚合等多种操作。

4.1什么是Stream

Stream是一个来自数据源的元素队列并支持聚合操作，更像是一个更高版本的Iterator,原始版本的Iterator，只能一个个遍历元素并完成相应操作。而使用Stream，只需要指定什么操作，如“过滤长度大于10的字符串”等操作，Stream会内部遍历并完成指定操作。

Stream中的元素在管道中经过中间操作（intermediate operation）的处理后，最后由最终操作（terminal operation）得到最终的结果。

• 数据源：是Stream的来源，可以是集合、数组、I/O channel等转换而成的Stream；
• 基本操作：类似于SQL语句一样的操作，比如filter,map,reduce,find,match,sort等操作。

当我们操作一个流时，实际上会包含这样的执行过程：

获取数据源-->转换成Stream-->执行操作，返回一个新的Stream-->再以新的Stream继续执行操作--->直至最后操作输出最终结果。

4.2生成Stream的方式

生成Stream的方式主要有这样几种：

1. 从接口Collection中和Arrays：
   • Collection.stream();
   • Collection.parallelStream(); //相较于串行流，并行流能够大大提升执行效率
   • Arrays.stream(T array);
2. Stream中的静态方法：
   • Stream.of()；
   • generate(Supplier s);
   • iterate(T seed, UnaryOperator f);
   • empty();
3. 其他方法
   • Random.ints()
   • BitSet.stream()
   • Pattern.splitAsStream(java.lang.CharSequence)
   • JarFile.stream()
   • BufferedReader.lines()

下面对前面常见的两种方式给出示例：

public class StreamTest {


    public static void main(String[] args) {
        //1.使用Collection中的方法和Arrays
        String[] strArr = new String[]{"a", "b", "c"};
        List list = Arrays.asList(strArr);
        Stream stream = list.stream();
        Stream stream1 = Arrays.stream(strArr);

        //2. 使用Stream中提供的静态方法
        Stream stream2 = Stream.of(strArr);
        Stream stream3 = Stream.generate(Math::random);
        Stream