java1.8新特性

一、java 8 Lambda表达式
  Lambda表达式，也可以成为闭包，它是推动Java8发布的重要新特性
  Lambda允许把函数作为一个方法的参数
  使用Lambda表达式可以使代码变的更加简洁紧凑
 二、java 8 方法引用
  方法引用通过方法的名字来指向一个方法
  方法引用可以使语言的构造更紧凑简洁，减少沉余代码
  方法引用使用一对冒号：：
 三、java 8 函数式接口
  函数式接口可以被隐式转为lambda表达式
  函数式接口可以现有的函数友好地支持lambda
 四、java 8 默认方法
  只需在方法名前面加个default关键字即可实现默认方法
  为了解决接口的修改与现有的实现不兼容的问题
 五、java 8 Stream
  java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据
  Stream API可以极大提高java程序员的生产力，让程序员写出高效率，干净，简洁的代码
 六、java 8 Optional
  Optional类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
 七、java 8 Nashorn JavaScript
 八、java 8 日期时间API
  java.util.Date是非线程安全的
 九、java 8 Base64

下面附加几个代码实现

public class lambda {
    public static void main(String[] args) {
        lambda jLambda=new lambda();
        MathOperation addition= (int a,int b) -> a+b;
        MathOperation subtraction=(a,b) -> a-b;
        MathOperation multiplication=(int a,int b) ->{
            return a*b;
        };
        MathOperation divsion=(int a,int b) -> a/b;
        System.out.println("10+5="+jLambda.operate(10, 5, addition));
        
        GreetingService greetingService=message -> System.out.println("Hello"+message);
        GreetingService greetingService2=(message) -> System.out.println("Helllo"+message);
        greetingService.sayMessage("R");
        greetingService2.sayMessage("G");
    }
    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);
    }
}

public class final引用 {
    public static void main(String[] args) {
        final int num=1;
        Converter<Integer, String> converter=param -> System.out.println(String.valueOf(param + num));
        converter.convert(2);
    }
    interface Converter<T1,T2>{
        void convert(int i);
    }
}

public class 函数式接口 {
    public static void main(String[] args) {
        
        List<Integer> list=Arrays.asList(1,2,3,4,5,6);
        System.out.println("输出所有数据");
        eval(list,n->true);
    }
    public static void eval(List<Integer> list,Predicate<Integer> predicate) {
        for(Integer n:list) {
            if(predicate.test(n)) {
                System.out.println(n+"");
            }
        }
    }
}

public class 方法引用 {
    @FunctionalInterface
    public interface Supplier<T>{
        T get();
    }
    public static 方法引用 create(final Supplier<方法引用> supplier) {
        return supplier.get();
    }
    public static void collide(final 方法引用 car) {
        System.out.println("Collided"+car.toString());
    }
    public void follow(final 方法引用 another) {
        System.out.println("Following the"+another.toString());
    }
    public void repair() {
        System.out.println("Repaired"+this.toString());
    }
    public static void main(String[] args) {
        方法引用 car =方法引用.create(方法引用::new);
        方法引用 car1=方法引用.create(方法引用::new);

        List<方法引用> list=Arrays.asList(car,car1);
        System.out.println("构造器引用");
        list.forEach(方法引用::collide);
        System.out.println("静态方法引用");
        list.forEach(方法引用::repair);
        System.out.println("特定类的任意对象的方法引用");
        final 方法引用 police=方法引用.create(方法引用::new);
        list.forEach(police::follow);
        System.out.println("特定对象的方法引用");
    }
}

public class 方法引用2 {
    public static void main(String[] args) {
        List names=new ArrayList();
        names.add("A");
        names.add("B");
        names.add("C");
        names.add("D");
        names.add("E");
        names.forEach(System.out::println);
    }
}