Java 8新增Lambda表达式(6.8)

参考《Java疯狂讲义》
Lambda表达式支持将代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（这种接口被称为函数式接口）的实例

1. Lambda表达式入门

下面先使用匿名内部类来改写（6.6介绍的命令模式Command表达式的例子）

public class CommandTest
{
   public static void main(String[] args)
   {
      ProcessArray pa = new ProcessArray();
      int[] array = {3, -4, 6, 4};
      // 处理数组，具体处理行为取决于匿名内部类
      pa.process(array , new Command()
         {
            public void process(int[] target)
            {
               int sum = 0;
               for (int tmp : target )
               {
                  sum += tmp;
               }
               System.out.println("数组元素的总和是:" + sum);
            }
         });
   }
}

程序通过匿名内部类实例来封装处理行为。而Lambda表达式完全可以简化创建匿名内部类对象。

public class CommandTest2
{
   public static void main(String[] args)
   {
      ProcessArray pa = new ProcessArray();
      int[] array = {3, -4, 6, 4};
      // 处理数组，具体处理行为取决于匿名内部类
      pa.process(array , (int[] target)->{
            int sum = 0;
            for (int tmp : target )
            {
               sum += tmp;
            }
            System.out.println("数组元素的总和是:" + sum);
         });
   }
}

通过上面的对比可知；Lambda表达式主要就是代替匿名内部类的繁琐语法。不需要new Xxx(){}的语法，不需要指出重写方法的名字，也不需要给出重写方法的返回值类型——只需要给出重写方法的形参列表即可。
当使用Lambda表达式代替匿名内部类创建对象时，Lambda表达式的代码块将会替代实现抽象方法的方法体，Lambda表达式就相当于一个匿名方法。
他由三部分组成；

形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的括号都能省略。
箭头。英文划线和大于号组成。
代码块。如果代码块只有一条语句，Lambda表达式允许省略代码块的花括号，那么这条语句就不要用花括号表示语句的结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而他的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回该语句的值。

下面示范Lambda表达式的几种简单写法；

interface Eatable
{
   void taste();
}
interface Flyable
{
   void fly(String weather);
}
interface Addable
{
   int add(int a , int b);
}
public class LambdaQs
{
   // 调用该方法需要Eatable对象
   public void eat(Eatable e)
   {
      System.out.println(e);
      e.taste();
   }
   // 调用该方法需要Flyable对象
   public void drive(Flyable f)
   {
      System.out.println("我正在驾驶" + f);
      f.fly("【碧空如洗的晴日】");
   }
   // 调用该方法需要Addable对象
   public void test(Addable add)
   {
      System.out.println("5与3的和为" + add.add(5, 3));
   }
   public static void main(String[] args)
   {
      LambdaQs lq = new LambdaQs();
      // Lambda表达式的代码块只有一条语句，可以省略花括号
      lq.eat(()-> System.out.println("苹果的味道不错"));
      // Lambda表达式的形参列表只有一个形参，可以省略圆括号
      lq.drive(weather ->
      {
         System.out.println("今天天气是" + weather);
         System.out.println("ֱ直升机飞行平稳");
      });
      //Lambda表达式的代码块只有一条语句，可以省略花括号
      // 代码块只有一条语句，即使该表达式需要返回值，也可以省略return关键字
      lq.test((a , b)->a + b);
   }
}

2. Lambda表达式与函数式接口
Lambda表达式的类型，也被称为“目标类型(target type)”,Lambda表达式的目标类型必须是“函数式接口(functional interface)”。函数式接口代表只包含一个抽象方法的接口。函数式接口可以有多个默认方法，类方法，但只能声明一个抽象方法。

Java 8 专门为函数式接口提供了@FunctionalInterface注解，该注解通常放在接口定义前面，该注解对程序功能没有任何作用，它用于告诉编译器执行更严格的检查——检查该接口必须是函数式接口，否者编译器报错。

@FunctionalInterface
interface FkTest
{
   void run();
}

public class LambdaTest
{
   public static void main(String[] args)
   {
      // Runnable接口中只包含一个无参数的方法
      // Lambda表达式代表的匿名方法实现了Runnable接口中唯一的，无参数的方法
      // 因此下面的Lambda表达式创建了一个Runnable对象
      Runnable r = () -> {
         for(int i = 0 ; i < 100 ; i ++)
         {
            System.out.println();
         }
      };
      // 下面代码将出现错误:Object不是函数式接口
      //Object obj = () -> {
      //    for(int i = 0 ; i < 100 ; i ++)
      //    {
      //      System.out.println();
      //    }
      //};
      //对Lambda表达式进行强制类型转换，这样就可以确定该表达式的目标类型为Runnable函数式接口
      Object obj1 = (Runnable)() -> {
         for(int i = 0 ; i < 100 ; i ++)
         {
            System.out.println();
         }
      };
      //同样的Lambda表达式可以被当成不同的目标类型，唯一的要求是：
      // Lambda表达式的参数列表与函数式接口中唯一抽象方法的形参列表相同ͬ
      Object obj2 = (FkTest)() -> {
         for(int i = 0 ; i < 100 ; i ++)
         {
            System.out.println();
         }
      };

   }
}

从以上代码可以得出一些结论：
Lambda表达式实现的是匿名方法——因此它只能实现特定的函数接口中唯一的方法。这就意味着Lambda表达式有如下两个限制：（1）Lambda表达式的目标类型只能是明确的函数式接口。（2）Lambda表达式只能为函数式接口创建对象。
为了保证Lambda表达式的目标类型是一个明确的函数式接口，可以有如下三种方式：（1）将Lambda表达式赋值给函数式接口类型的变量（2）将Lambda表达式作为函数式接口类型的参数传给某个方法（3）使用函数式接口对Lambda表达式进行强制类型转换
Java 8 在java.util.function包下预定了大量函数式接口，典型有4类接口：

XxxFunction：这类接口中通常包含一个apply()抽象方法，该方法对参数进行处理（处理逻辑由Lambda表达式决定），然后返回一个新的值
XxxConsumer：这类接口中通常包含一个accept()抽象方法，该方法与上面的方法相似，只是没有返回值
XxxPredicate：这类接口中通常包含一个test()抽象方法，该方法用于对参数进行某种判断（由Lambda表达式决定），然后返回一个Boolean类型的值
XxxSupplier：这类接口中通常包含一个getAsXxx()抽象方法，该方法没有参数，会按某种逻辑算法（由Lambda表达式决定）返回一个数据

3. 方法引用与构造器引用
如果Lambda表达式的代码块只有一条代码，不仅可以省略花括号，还可以在代码块中使用方法引用和构造器引用。
方法引用和构造器引用可以让Lambda表达式的代码块更加简洁，方法引用和代码块引用都要使用两个英文冒号。

引用类方法

@FunctionalInterface
interface Converter{
   Integer convert(String from);
}
/下面代码使用Lambda表达式创建Converter对象
Converter converter1 = from -> Integer.valueOf(from);
Integer val = converter1.convert("99");
System.out.println(val); // 将输出99

使用一行调用类方法进行替换

// 方法引用代替Lambda表达式：引用类方法
// 函数式接口中被实现的全部参数传给该类方法作为参数
Converter converter1 = Integer::valueOf;

引用特定对象的实例方法

// 下面代码使用Lambda表达式创建Converter对象
Converter converter2 = from -> "fkit.org".indexOf(from);

Integer value = converter2.convert("it");
System.out.println(value); // 输出2

// 方法引用代替Lambda表达式，引用特定对象的实例方法
// 函数式接口中被实现的全部参数传给该方法作为参数
Converter converter2 = "fkit.org"::indexOf;

3.引用某类对象的实例方法

@FunctionalInterface
interface MyTest
{
   String test(String a , int b , int c);
}
//下面代码使用Lambda表达式创建MyTest对象
MyTest mt = (a , b , c) -> a.substring(b , c);

String str = mt.test("Java I Love you" , 2 , 9);
System.out.println(str); // 输出:va I Lo
// 方法引用代替Lambda表达式，引用某类对象的实例方法
// 函数式接口中被实现的第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
MyTest mt = String::substring;

引用构造器

@FunctionalInterface
interface YourTest
{
   JFrame win(String title);
}
// 下面代码使用Lambda表达式创建YourTest对象
YourTest yt = (String a) -> new JFrame(a);

JFrame jf = yt.win("我的窗口");
System.out.println(jf);

//构造器引用代替Lambda表达式
// 函数式接口中被实现的全部参数传给该构造器作为参数
YourTest yt = JFrame::new;

4. Lambda表达式与匿名内部类的联系与区别
Lambda表达式是匿名内部类的一种简化
相同点：

Lambda表达式与匿名内部类一样，都可以直接访问“effectively final”的局部变量，以及外部类的成员变量。
Lambda表达式与匿名内部类创建的对象一样，都可以直接调用从接口中继承的默认方法
不同之处：
匿名内部类可以为任何接口创建实例——不管接口包含多少个抽象方法，只要匿名内部类实现了所有抽象方法即可；但 Lambda表达式只能为函数式接口创建对象
匿名内部类可以为抽象类甚至普通类创建对象
匿名内部类实现的抽象方法的方法体允许调用接口中的默认方法；但 Lambda表达式的代码块不允许调用接口中的默认方法

5. 使用 Lambda表达式调用Arrays的类方法

public class LambdaArrays
{
   public static void main(String[] args)
   {
      String[] arr1 = new String[]{"java" , "fkava" , "fkit", "ios" , "android"};
      Arrays.parallelSort(arr1, (o1, o2) -> o1.length() - o2.length());
      System.out.println(Arrays.toString(arr1));
      int[] arr2 = new int[]{3, -4 , 25, 16, 30, 18};
      // left代表素组中前一个索引处的元素，计算第一个元素时，left为1
      // right代表素组中当前索引处的元素
      Arrays.parallelPrefix(arr2, (left, right)-> left * right);
      System.out.println(Arrays.toString(arr2));
      long[] arr3 = new long[5];
      // operand代表正在计算的元素索引      
      Arrays.parallelSetAll(arr3 , operand -> operand * 5);
      System.out.println(Arrays.toString(arr3));
   }
}

Java 8新增Lambda表达式(6.8)

猜你喜欢