Java中的Lambda表达式

函数式接口和Lambda表达式

一、函数式接口和Lambda均是JDK1.8新引入的概念。Lambda表达式开启了java语言支持函数式编程的新时代，是支持函数式编程的基础。Lambda表达式指的是应用在只含有一个抽象函数的接口下的一种简单定义形式，可以解决匿名内部类的定义复杂度问题。

二、函数式接口

1、函数是接口是指只包含一个抽象方法的接口，因此也被称为单抽象方法接口。每一个Lambda表达式都对应一个函数式接口，可以将Lambda看成是实现函数式接口的匿名内部类的一个对象。为了让编译器能确保一个接口满足函数式接口的要求，Java1.8提供了@FunctionalInterface注解，如Runnable接口就是一个函数式接口，其注解方式如下：

@FunctionalInterface   //强调下面的接口是一个函数式接口
public interface Runnable{
    void run();
}

2、如果函数使用了@FunctionalInterface来注释，而本身并非函数式接口，则在编译时出错。函数式接口只能有一个抽象方法需要被实现，但以下特殊情况除外。

（1）、函数式接口可以有Object类中覆盖的方法，也就是equals()、toString()、hashcode()等方法。例如，Comparator接口就是一个函数式接口，它的源码如下：

public interface Comparator<T>{   //该接口为泛型接口，<T>为类型参数
    int comparator(To1,To2);
    boolean equals(object obj);   //父类Object中的方法
}

package 多线程与并发.Lamda表达式;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class TestLambda3 {
    public static void main(String[] args) {
        String[] names={"赵云","刘备","张飞","关羽"};
        List<String> al = Arrays.asList(names);//调用静态方法asList()创建列表对象al
        System.out.println("用匿名内部类方法遍历输出：");
        al.forEach(new Consumer<String>()  //创建匿名内部类对象
                   {
                       @Override      //必须覆盖下面的accept()方法
                      public void accept(String s) //实现函数式接口Consumer中的accept()方法
                      {
                          System.out.println(s);
                      }
                   }
                  );
        System.out.println("\n使用lambda表达式遍历输出：");
        al.forEach((s)->System.out.println(s));//使用Lambda表达式遍历输出al的元素
        System.out.println("\n使用方法引用的方式遍历输出al的元素：");
        al.forEach(System.out::println);
    }
}

这里是java8 的新特性的应用。forEach是属于java集合的一个方法，准确来说，集合在java8中拥有一个stream方法，可以得到一个流对象，这个对象拥有很多方法，这些方法可以很方便的对集合进行例如排序，分组，计数，遍历，转换等操作，而遍历是比较常见的一种，forEach就是用来做这个的，这里的forEach就是stream的forEach。java此时还有另外一个特性叫做lambda表达式和函数式接口，仅仅有一个未实现方法的接口，可以直接写作(参数列表) -> { 方法体 }这种形式。

例如：

@FunctionalInterface public interface FuncA { 
      void doSomeThing(String str);
} 
//那么上面这种接口就可以直接写作：
FuncA funcA = (str) -> {System.out.println(“hello”);};

类似的还有Swing或者javaFx的监听器：

btn.addActionListener(e->{ // do something});

这样就省去了之前需要专为他编写一个实现类或者匿名内部类的代码，直接对接口进行实现。而在这之上，如果一个方法的调用中，这个方法给接口提供的参数和他接收的返回，和你现有某个实现完全一致，就可以进一步进行简化，称为方法引用。forEach方法提供一个某种类型的Object（具体是什么类型是要看Stream类的泛型参数的，不过一般就是这个集合提供的那种类型），而System.out.println可以接受一个Object，因此，forEach提供的参数和System.out.println的参数类型是一致的，可以进行这种简写。具体来说就是：原本应该写为：.forEach(element -> {System.out.println(element)})但System.out.println的参数和传递的参数element 的类型完全匹配，所以这样的时候就可以简化为：.forEach（System.out::println)

package 多线程与并发.Lamda表达式;
public class TestLambda {
    //1、静态内部类
   static class Like1 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
​
        like = new Like1();
        like.lambda();
​
        //2、局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I love you3");
            }
        }
            like = new Like3();
            like.lambda();
        //3、匿名内部类
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I love you4");
            }
        };
        like.lambda();
​
        //4、用lambda化简
        like = ()-> {
                System.out.println("I love you5");
            };
        like.lambda();
    }
}
​
//定义一个函数式接口
//函数式接口：任何接口，如果只包含了唯一一个抽象方法，那么他就是一个函数式接口。
interface ILike{
    void lambda();
}
​
//函数式接口的实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}