JavaSE——Java8之函数式接口、函数式编程、Lambda表达式

一、函数式接口

1、概念

  函数式接口的几点特征：

   函数式接口只有一个抽象方法；
   default方法某默认实现，不属于抽象方法；
   接口重写了Object的公共方法也不算入内。

  函数式接口的应用场景：函数式编程，而在Java中的函数式编程就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中只有一个抽象方法，Lambda表达式才能顺利的进行推导。

2、格式：

   修饰符 interface 接口名 {
      public abstract 返回值类型 方法名(参数...){
      }
   }

3、函数式接口的注解

    //加在接口的上面，如果出现报红，就说明不是函数式接口
    @FunctionalInterface

4、函数式接口的使用

代码演示：

/**
 * 函数式接口
 */
@FunctionalInterface
public interface MyInterface {
    public abstract void show();
}
**
 * 函数式接口的实现类
 */
public class MyInterfacelIml implements MyInterface {
    @Override
    public void show() {
        System.out.println("接口实现类 show...");
    }
}
/**
 * 测试
 */
public class FunctionalDemo {
    public static void show(MyInterface myInterface){
        myInterface.show();
    }
    public static void main(String[] args) {
        //show方法中的参数的几种写法：
        //1、接口的实现类
        show(new MyInterfacelIml());
        //2、匿名内部类
        show(new MyInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类show...");
            }
        });
        //3、方法的参数是一个函数式接口，所以可以使用Lambda表达式
        show(()->{
            System.out.println("Lambda show...");
        });
        //4、简化的Lambda表达式
        show(()-> System.out.println("Simplify Lambda show..."));
    }
}

执行结果：

二、函数式编程

1、使用Lambda表达式作为参数和返回值

   Java中的Lambda表达式可以当作是匿名内部类的替代品。如果方法的参数是一个函数式接口式类型，就可以使用Lambda进行替代。使用Lambda表达式作为方法的参数，其实就是使用函数式接口作为方法的参数；类似的，如果方法的返回值类型是一个函数式接口的类型，就可以直接返回一个Lambda表达式。

案例1： 在多线程使我们学习过的 java.lang.Runnable 接口就是一个函数式接口，假设有一个startThread方法使用该接口作为参数，就可以使用Lambda进行传参。

/**
 * 函数式接口作为方法的参数
 */
public class MyRunnableDemo  {
    //定义方法startThread,方法的参数是Runnable接口类型
    public static void startThread(Runnable runnable){
        //开启一个线程
        new Thread(runnable).start();
    }

    public static void main(String[] args) {
        //使用匿名内部类作为参数
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"..."+"线程启动了");
            }
        });
        //使用Lambda表达式作为参数
        startThread(()-> System.out.println(Thread.currentThread().getName()+"..."+"线程启动了"));
    }
}

案例2： Java 中的比较器接口也是一个函数式接口，使用函数式接口作为方法的返回值。

代码：

import java.util.Arrays;
import java.util.Comparator;

/**
 * 函数式接口作为方法的返回值类型
 */
public class MyComparatorDemo {
    //使用匿名内部类返回
    public static Comparator<String> getComparator1() {
        return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.length() - s1.length();
            }
        };
    }
    //使用Lambda返回
    public static Comparator<String> getComparator(){
        return (String s1,String s2)->{
            return s1.length()-s2.length();
        };
    }

    public static void main(String[] args) {
        String[] arr = {"ccc","a","bb","dddd"};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr,getComparator());
        System.out.println(Arrays.toString(arr));
    }
}

执行结果：