jdk1.8新特性，常用函数式接口与Lambda表达式应用

JDK1.8新特性：

1.接口中可以定义:

(1)带方法体的默认方法default修饰：调用方式通过实例化子类去调用。
(2)带方法体的静态方法：调用方法直接类名调用。
接口中只有不带方法体的抽象方法和带方法体的默认方法，可以被重写，而静态方法不可以被重写。

lambda表达式是java1.8中的重要特性，其基于函数式编程的思想，支持将代码作为方法参数进行使用，可以把lamda表达式理解为通过一种更简洁的方式表示可传递的匿名函数。

2.Lambda使用规范：

(1)基础格式:(参数列表)->{方法体}
方法体用来执行业务逻辑，可以是单一语句，也可以是语句块，如果是单一语句花括号可以省略，当需要返回值，如果方法体中只有一条语句，可以省略return，会自动根据结果进行返回。
(2)没有参数的lambda表达式：()->new Student
(3)只有一个参数的lambda表达式（会根据上下文判断数据类型）

x->{ system.out.prient(x); return x;} 

(4)多个参数的lambda表达式（会根据上下文判断数据类型）：

(int x,inty)->{system.out.println(x);system.out.println(y) ;return x+y}

(5)一条语句一个参数lambda表达式：

x->3+x

(6)多个参数一条语句lambda表达式：

(x,y)->x+y

(7)Lambda替换匿名内部类：

 //替换前
 Runnable runnable= new Runnable(){
     @Override
     public void run{
         System.out.println("a");
     }
 };
//替换后
 Runnable runnable = ()-> System.out.println()("a");


//替换前
 Arrays.sort(array,new Comparator<String>(){
     @Override
     public int compare(String o1,String o2){
         return o1.compareTo(o2);
     }
 });
 //替换后
 Arrays.sort(array,(o1,o2)-> o1.compareTo(o2));

3.函数式接口：

函数式接口：仅有一个抽象方法的普通接口，如果声明多个抽象接口会报错，但是默认的方法和静态方法再此接口中可以定义多个。
定义：定义一个函数式接口需要在类上加@FunctionalInterface。
例子：

@FunctionalInterface
public interface MyFunctionalInterface {
    void exec();//只允许有一个抽象方法
}

public class Demo1 {

    public void invork(MyFunctionalInterface myFunctionalInterface){
        myFunctionalInterface.exec();
    }

    @Test
    public void test1(){
        invork(new MyFunctionalInterface() {
            @Override
            public void exec() {
                System.out.println("匿名内部类");
            }
        });
    }

    @Test
    public void test2(){
        invork(()-> System.out.println("测试函数式接口"));
    }
}

Lambda表达式中的方法体就是函数式接口的抽象方法的实现

5.常见的函数式接口Predicate、Consumer、Function、Supplier

(1)Predicate：java.util.function包下作用用来进行数据判断,抽象方法【boolean test(T t)】
例子：

public class MyPredicate {
    public static List<UserEntity> filter(List<UserEntity> users, Predicate<UserEntity> predicate){
       List<UserEntity> list= new ArrayList<>();
        users.forEach(user->{
           if(predicate.test(user))
           {
               list.add(user);
           }
        });
        return list;
    }

    public static void main(String[] args) {
        UserEntity userEntity0 = new UserEntity("张三",23);
        UserEntity userEntity1 = new UserEntity("王五",24);
        UserEntity userEntity2 = new UserEntity("李四",13);
        List<UserEntity> list=new ArrayList<>();
        list.add(userEntity0);
        list.add(userEntity1);
        list.add(userEntity2);
        List<UserEntity> filter = filter(list, (user) -> user.getAge() > 13);
        System.out.println(JSON.toJSONString(filter));

    }
}

(2)Consumer：java.util.function包下作用用来进行数据的获取,抽象方法【void accept(T t)】
例子：

public class MyConsumer {

    public static void  foreach(List<String> list, Consumer<String> consumer){
        list.forEach(a->consumer.accept(a));
    }

    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        foreach(list,(x)-> System.out.println(x));
    }
}

(3)Function：java.util.function包下作用用来进行类型的转换,抽象方法【R apply(T t)】
例子：

public class MyFunction {

    public static Double convert(BigDecimal bigDecimal, Function<BigDecimal,Double> function){
        return function.apply(bigDecimal);
    }

    public static void main(String[] args) {
        BigDecimal bigDecimal=new BigDecimal("1.21");
        Double convert = convert(bigDecimal,(a) -> Double.valueOf(a.toString())+12);
        System.out.println(convert);
    }
}

(4)Supplier：java.util.function包下作用用来获取值操作有返回值,抽象方法【T get()】
例子：

public class MySupplier {
    public static Integer getMin(Supplier<Integer> supplier){
       return supplier.get();
    }

    public static void main(String[] args) {
        int array[]={11,121,-12,33,0,43};
        Integer minNum = getMin(() -> {
            int min = array[0];
            for (int num : array) 
            {
                if (num < min) 
                {
                    min = num;
                }
            }
            return min;
        });
        System.out.println(minNum);
    }
}