java8：函数式接口

1、Comparator接口

@FunctionalInterface
public interface Comparator<T> {

（1）普通方式：

public static void main(String[] args) {
        List<String>list= Arrays.asList("ni","hao");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);
    }

（2）方式二：

    public static void main(String[] args) {
        List<String>list= Arrays.asList("ni","hao");
        Collections.sort(list,(String o1,String o2)->{
            return o2.compareTo(o1);
        });
        System.out.println(list);
    }

（3）方式三：

  public static void main(String[] args) {
        List<String>list= Arrays.asList("ni","hao");
        Collections.sort(list,(o1,o2)->o2.compareTo(o1));
        System.out.println(list);
    }

2、lambda表达式的作用

（1）可以传递行为，而不仅仅是值

提升抽象层次

API重用性更好

更加灵活

3、基本语法

（参数）->{方法体}

（arg1,,arg2）->(body)

举例：

（int a,int b）->{return a+b;}//表示一个加法操作

（）->System.out.println("ni hao");//打印

(String s)->{System.out.println(s);}//打印出参数的值

()->42//不接收参数，返回42

4、lambda表达式的结构

（1）lambda表达式可以有零个或多个参数

（2）参数的类型既可以明确声明，也可以根据上下文来推断。例如：（int a）与（a）效果一样

（3）所有的参数都必须包含在圆括号内，参数之间用逗号相隔。例如：（a,b）或（int a, int b）

（4）空的圆括号代表参数集为空

（5）当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a->return a*a
（6）Lambda 表达式的主体可包含零条或多条语句
（7）如果Lambda表达式的主体只有一条语句，花括号可省略。匿名函数的返回类型与该主体表达式一致
（8）如果Lambda表达式的主体包含一条以上语句，则表达式必须包含在花括号中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

5、Function接口举例

（1）源码：

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

（2）运用：

 public int compute(int a,Function<Integer,Integer> function){
        int result=function.apply(a);
        return result;
    }
    public static void main(String[] args) {
        Test1 test1=new Test1();
        System.out.println(test1.compute(1,value->{return 2*value;}));
        System.out.println(test1.compute(2,value->5+value));
        System.out.println(test1.compute(3,value->value*value));
    }

另外一种书写方式：

    public int compute(int a,Function<Integer,Integer> function){
        int result=function.apply(a);
        return result;
    }
    public static void main(String[] args) {
        Test1 test1=new Test1();
        Function<Integer,Integer> function=value-> value *2;
        System.out.println(test1.compute(4,function));
    }

拼接字符串：

    public String convert(int a,Function<Integer,String> function){
        return function.apply(a);
    }
    public static void main(String[] args) {
        Test1 test1=new Test1();
        System.out.println(test1.convert(34,value->String.valueOf(value+"hello")));
    }

与以前的先定义函数，然后创建对象调用函数不同，采用lambda表达式的方式是在调用函数的时候才向函数指出行为（即：函数的操作），而普通情况下是在函数中已经定义好了行为，对象直接调用即可。

6、高阶函数

如果一个函数接受一个函数作为参数，或者返回一个函数作为返回值

 public String convert(int a,Function<Integer,String> function){
        return function.apply(a);
    }

原文地址：https://www.cnblogs.com/zhai1997/p/12594613.html