Lambada表达式之初入江湖

最新推荐文章于 2022-12-08 00:23:32 发布

程序员阿超

最新推荐文章于 2022-12-08 00:23:32 发布

阅读量196

点赞数

分类专栏： Lambada表达式文章标签： lambda java

本文链接：https://blog.csdn.net/qq_42980970/article/details/106809890

版权

Lambada表达式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.1回顾匿名内部类
要启动一个线程，需要创建一个 Thread 类的对象并调用 start 方法。而为了指定线程执行的内容，需要调用 Thread 类的构造方法：
public Thread(Runnable target)
为了获取 Runnable 接口的实现对象，可以为该接口定义一个实现类 RunnableImpl ：

public class RunnableImpl implements Runnable {
 @Override 
      public void run() {
            System.out.println("多线程任务执行！");
      }
}

然后创建该实现类的对象作为 Thread 类的构造参数：

public class Demo03ThreadInitParam {
    public static void main(String[] args) {
          Runnable task = new RunnableImpl();
             new Thread(task).start();
    }
}

1.2使用匿名内部类
这个 RunnableImpl 类只是为了实现 Runnable 接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：

public class Demo04ThreadNameless {
 public static void main(String[] args) {
    new Thread(new Runnable() {
       @Override
       public void run() {
          System.out.println("多线程任务执行！");
       }
   }).start();
 }
}

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

函数式编程重点在函数上,在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情最后有什么结果”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”.

比如: 我要计算: y = 3*x+4,其中x就是输入量 3x+4就是做什么,最后的y就是计算的结果

而函数式思想是尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。

1.3 冗余的Runnable代码

对于 Runnable 的匿名内部类用法，可以分析出几点内容：

Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。

1.4 体验Lambda的更优写法
借助Java 8的全新语法，上述 Runnable 接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class Demo02LambdaRunnable { 
     public static void main(String[] args) {
       new Thread(() ‐> System.out.println("多线程任务执行！")).start(); // 启动线程
     }
}

这段代码和刚才的执行效果是完全一样的，可以在1.8或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。
不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！ Lambda是怎样击败面向对象的？在上例中，核心代码其实只是如下所示的内容：

() ‐> System.out.println("多线程任务执行！")

1.5 语义分析
仔细分析该代码中的语义， Runnable 接口只有一个 run 方法的定义：
public abstract void run();

即制定了一种做事情的方案（其实就是一个函数）：
无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。

() ‐> System.out.println("多线程任务执行！")

前面的一对小括号即 run 方法的参数（无），代表做这件事不需要参数；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

1.6 Lambda标准格式
Lambda省去面向对象的条条框框，格式由3个部分组成：
一些参数
一个箭头
一段代码

Lambda表达式的标准格式为：
(参数类型参数名称) ‐> { 代码语句;return 值; }

格式说明：
小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。

—> 是新引入的语法格式，代表指向动作(做什么事)。
大括号内的语法与传统方法体要求基本一致

1.7 示例：使用Lambda标准格式（无参无返回）
给定一个厨子 Cook 接口，内含唯一的抽象方法 makeFood ，且无参数、无返回值。如下：

public interface Cook {
     void makeFood();
}

public class Demo05InvokeCook {
     public static void main(String[] args) {
       invokeCook(() ‐> { System.out.println("吃饭啦！");});
     }
     private static void invokeCook(Cook cook) { 
          cook.makeFood();
     }
}

备注：小括号代表 Cook 接口 makeFood 抽象方法的参数为空，大括号代表 makeFood 的方法体。

1.8 Lambda的参数和返回值
下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：
public abstract int compare(T o1, T o2);

当需要对一个对象数组进行排序时， Arrays.sort 方法需要一个 Comparator 接口实例来指定排序的规则。假设有一个 Person 类，含有 String name 和 int age 两个成员变量：

public class Person {
      private String name;
      private int age;
      // 省略构造器、toString方法与Getter Setter
}

传统写法
如果使用传统的代码对 Person[] 数组进行排序，写法如下：

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
   public static void main(String[] args) {
                 // 本来年龄乱序的对象数组
           Person[] array = {
                    new Person("古力娜扎", 19),
                    new Person("迪丽热巴", 18),
                    new Person("马尔扎哈", 20) };
   // 匿名内部类
   Comparator<Person> comp = new Comparator<Person>(
       @Override 
      public int compare(Person o1, Person o2) { 
      return o1.getAge() ‐ o2.getAge(); 
      } 
   };
    Arrays.sort(array, comp); 
   // 第二个参数为排序规则，即Comparator接口实例
   for (Person person : array) {  
        System.out.println(person);
   }
  }
}

这种做法在面向对象的思想中，似乎也是“理所当然”的。其中 Comparator 接口的实例（使用了匿名内部类）代表了“按照年龄从小到大”的排序规则。

代码分析
下面我们来搞清楚上述代码真正要做什么事情。
为了排序， Arrays.sort 方法需要排序规则，即 Comparator 接口的实例，抽象方法 compare 是关键；
为了指定 compare 的方法体，不得不需要 Comparator 接口的实现类；
为了省去定义一个 ComparatorImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 compare 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
实际上，只有参数和方法体才是关键。

Lambda写法

Arrays.sort(array, (Person a, Person b) ‐> { 
      return a.getAge() ‐ b.getAge();
});

1.9 示例：使用Lambda标准格式（有参有返回）
给定一个计算器 Calculator 接口，内含抽象方法 calc 可以将两个int数字相加得到和值：

public interface Calculator {
     int calc(int a, int b);
}

标准格式调用 invokeCalc 方法，完成120和130的相加计算：

public class Demo08InvokeCalc {
     public static void main(String[] args) {
       invokeCalc(120, 130, (int a, int b) ‐> {
         return a + b;  }); 
     }
     private static void invokeCalc(int a, int b, Calculator calculator) {
            int result = calculator.calc(a, b);
            System.out.println("结果是：" + result);
     }
}

备注：小括号代表 Calculator 接口 calc 抽象方法的参数，大括号代表 calc 的方法体。

3.10 Lambda省略格式
可推导即可省略
Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可以使用Lambda的省略写法：

public static void main(String[] args) {
    invokeCalc(120, 130, (a, b) ‐> a + b);
}

省略规则
在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

3.11 Lambda的使用前提
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
```
 	备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
```

以下介绍函数式接口

1.1概念
函数式接口在Java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

1.2函数式接口的定义
与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

import java.lang.FunctionalInterface;

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

1.3自定义函数式接口（无参无返回）
对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class FunctionalInterface {

    public static void doSomething(MyFunctionalInterface inner){
        inner.myMethod();
    }
    public static void main(String[] args) {
        doSomething(() -> System.out.println("Lambada表达式执行了"));
    }
}

1.4自定义函数式接口（有参有返回）
定义一个函数式接口 Sumable ，内含抽象 sum 方法，可以将两个int数字相加返回int结果。使用该接口作为方法的参数，并进而通过Lambda来使用它。

import java.lang.FunctionalInterface;

@FunctionalInterface
public interface Sumable {
    int sum(int a,int b);
}

public class DemoSumable {

    public static void showSum(int x, int y, Sumable sumable) {
        System.out.println(sumable.sum(x, y));
    }
    public static void main(String[] args) {
        showSum(10,20,(m,n) -> m+n);
    }
}

1.5 Lambda的延迟执行
一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class Demo01Logger {
    private static void log(int level, String msg) {
        if (level == 1) {
            System.out.println(msg);
        }
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, msgA + msgB + msgC);
    }
}

这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

刚刚我们体验了,日志案例中的性能浪费,现在我们该用函数式编程,即使用Lambda!! 我们把日志拼接功能交给函数式接口,调用接口中的方法来拼接,而不是我们自己拼接
使用Lambda必然需要一个函数式接口：

@FunctionalInterface 
public interface MessageBuilder {
  String buildMessage();
}

public class Demo02Logger {
  private static void log(int level, MessageBuilder builder) { 
   if (level == 1) { 
    System.out.println(builder.buildMessage()); 
   }     
 } 
 public static void main(String[] args) {
       String msgA = "Hello";
       String msgB = "World";
       String msgC = "Java";
       log(1, () ‐> msgA + msgB + msgC );
 }     
}

这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。

下面的代码可以通过结果进行验证

public class Demo02Logger {
    private static void log(int level, MessageBuilder builder) {
        if (level == 1) {
            System.out.println(builder.buildMessage());
        }
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(2, () -> {
            System.out.println("Lambada表达式执行了");
            return msgA + msgB + msgC;
        });
    }
}

从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

1.6 使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。
例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class Demo04Runnable {
    public static void startThread(Runnable task){
        new Thread(task).start();
    }
    public static void main(String[] args) {
        startThread(() -> System.out.println("线程任务执行"));
    }
}

类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时：

import java.util.Arrays;
import java.util.Comparator;
    public class Demo06Comparator {
        private static Comparator<String> getComparator() {
            return (a, b) -> b.length() - a.length();
        }
        public static void main(String[] args) {
            String[] array = {"a", "ab", "a"};
            Thread thread = new Thread();
            System.out.println(Arrays.toString(array));
            Arrays.sort(array, getComparator());
            System.out.println(Arrays.toString(array));
        }
    }

1.7自定义Lambda参数和返回值
自定义一个函数式接口 MySupplier ，含有无参数的抽象方法 get 得到 Object 类型的返回值。并使用该函数式接口分别作为方法的参数和返回值

使用该接口作为方法的参数，并且在传递参数时将实际参数写成Lambda：

@FunctionalInterface
 public interface MySupplier {
       Object get();
 }
 public class Demo1MySupplier {
    private static void printParam(MySupplier supplier) { 
       Object obj = supplier.get();
       System.out.println(obj);
  } 
    public static void main(String[] args) { 
           printParam(() ‐> "Hello");
  }
 }

使用该接口作为方法的返回值，也很简单：

public class Demo2MySupplier {
    private static MySupplier getData() {
            return () ‐> "Hello";
    }
    public static void main(String[] args) {
            MySupplier ms = getData();
            Object obj = ms.get(); 
            System.out.println(obj);
    }
}

1.8方法的引用
冗余的Lambda场景

@FunctionalInterface
 public interface Printable {
    void print(String str);
 }

在 Printable 接口当中唯一的抽象方法 print 接收一个字符串参数，目的就是为了打印显示它。那么通过Lambda 来使用它的代码很简单：

public class PrintSimple {
    private static void printString(Printable data) {
         data.print("Hello, World!");
    }
    public static void main(String[] args) { 
         printString(s ‐> System.out.println(s));
    }
}

其中 printString 方法只管调用 Printable 接口的 print 方法，而并不管 print 方法的具体实现逻辑会将字符串打印到什么地方去。而 main 方法通过Lambda表达式指定了函数式接口 Printable 的具体操作方案为：拿到 String（类型可推导，所以可省略）数据后，在控制台中输出它。

这段代码的问题在于，对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是 System.out 对象中的 println(String) 方法。既然Lambda希望做的事情就是调用 println(String) 方法，那何必自己手动调用呢？
1.9 用方法引用改进代码
能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“引用”过去就好了：

public class PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!"); 
    }
     public static void main(String[] args) {
        printString(System.out::println);
     } 
}

请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法。
2.0方法引用符
双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。
如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda 的替代者。

语义分析
例如上例中， System.out 对象中有一个重载的 println(String) 方法恰好就是我们所需要的。那么对于 printString 方法的函数式接口参数，对比下面两种写法，完全等效：

Lambda表达式写法：
s -> System.out.println(s);
方法引用写法： System.out::println

第一种语义是指：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。
第二种等效写法的语义是指：直接让 System.out 中的 println 方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。

推导与省略
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。

函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。下面这段代码将会调用 println 方法的不同重载形式，将函数式接口改为int类型的参数：

@FunctionalInterface
public interface PrintableInteger {
    void print(int str);
}

由于上下文变了之后可以自动推导出唯一对应的匹配重载，所以方法引用没有任何变化：

public class PrintOverload {
    private static void printInteger(PrintableInteger data) {
      data.print(1024); 
     } 
    public static void main(String[] args) {
       printInteger(System.out::println);
    }
}

这次方法引用将会自动匹配到 println(int) 的重载形式。
2.1 通过对象名引用成员方法
这是常见的一种用法，与上例相同。如果一个类中已经存在了一个成员方法：

public class MethodRefObject {
    public void printUpperCase(String str) {
       String bigStr = str.toUpperCase();
       System.out.println(bigStr);
     }
}

函数式接口仍然定义为：

@FunctionalInterface
public interface Printable {
    void print(String str);
}

那么当需要使用这个 printUpperCase 成员方法来替代 Printable 接口的Lambda的时候，已经具有了 MethodRefObject 类的对象实例，则可以通过对象名引用成员方法，代码为：

public class Demo04MethodRef {
     private static void printString(Printable lambda) {
        lambda.print("Hello");
     }
     public static void main(String[] args) {
        MethodRefObject obj = new MethodRefObject();
        printString(obj::printUpperCase);
      }
}

2.2 通过类名称引用静态方法
由于在 java.lang.Math 类中已经存在了静态方法 abs ，所以当我们需要通过Lambda来调用该方法时，有两种写法。首先是函数式接口：

@FunctionalInterface
public interface Calcable {
    int calc(int num);
 }

第一种写法是使用Lambda表达式：

public class Demo05Lambda {
     private static void method(int num, Calcable lambda) {
        int result = lambda.calc(num);   
        System.out.println(result);
     } 
     public static void main(String[] args) {
             method(‐10, n ‐> Math.abs(n));
     }
}

但是使用方法引用的更好写法是：

public class Demo06MethodRef {
     private static void method(int num, Calcable lambda) {
         System.out.println(lambda.calc(num));
     }       
     public static void main(String[] args) {
             method(‐10, Math::abs);
     }
}

在这个例子中，下面两种写法是等效的：
Lambda表达式： n -> Math.abs(n) 方法引用： Math::abs

假设有一个 StringUtils 字符串工具类，其中含有静态方法 isBlank 如下：

public final class StringUtils {
    public static boolean isBlank(String str) {  
         return str == null || "".equals(str.trim());
    }
}

定义一个函数式接口 StringChecker ，其中的抽象方法 checkBlank 的预期行为与 isBlank 一致，并定义一个方法使用该函数式接口作为参数。通过方法引用的形式，将 StringUtils 工具类中的 isBlank 方法作为Lambda的实现。

@FunctionalInterface
 public interface StringChecker {
     boolean checkString(String str);
  }
public class DemoStringChecker {
     private static void methodCheck(StringChecker checker) {
        System.out.println(checker.checkString("   "));
     }
     public static void main(String[] args) {
        methodCheck(StringUtils::isBlank);
      }
 }

2.3 通过super引用成员方法
如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。首先是函数式接口：

@FunctionalInterface
public interface Greetable {
    void greet();
}

public class Human {
    public void sayHello(){
        System.out.println("Hello!");
    }
}

public class Man extends Human {
    public void sayHello() {
         method(() -> super.sayHello());
    }
    private void method(Greetable lambda) {
        lambda.greet();
        System.out.println("I'm a man!");
    }
}

在这个例子中，下面两种写法是等效的：
Lambda表达式： () -> super.sayHello()
方法引用： super::sayHello

2.4通过this引用成员方法
this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口：

@FunctionalInterface
 public interface Richable { 
     void buy();
 }

下面是一个丈夫 Husband 类：

public class Husband { 
    private void marry(Richable lambda) {
            lambda.buy();
    }
    public void beHappy() {
            marry(() ‐> System.out.println("买套房子"));
    }
}

方法 beHappy 调用了结婚方法 marry ，后者的参数为函数式接口 Richable ，所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对 Husband 丈夫类进行修改：

public class Husband {
     private void buyHouse() {
             System.out.println("买套房子");
      } 
     private void marry(Richable lambda) {
                     lambda.buy(); 
      }
     public void beHappy() {
             marry(() ‐> this.buyHouse());
     }
}

如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：

public class Husband { 
    private void buyHouse() {
            System.out.println("买套房子");
    }
    private void marry(Richable lambda) {
            lambda.buy();
     } 
    public void beHappy() {
            marry(this::buyHouse);
    }
 }

在这个例子中，下面两种写法是等效的：
Lambda表达式： () -> this.buyHouse()
方法引用： this::buyHouse

2.5 类的构造器引用
由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new 的格式表示。首先是一个简单的 Person 类：

public class Person {
     private String name;
     public Person(String name) {
        this.name = name;
     } 
     public String getName() {
         return name; 
     }
}

然后是用来创建 Person 对象的函数式接口：

public interface PersonBuilder {
     Person buildPerson(String name);
}

要使用这个函数式接口，可以通过Lambda表达式：

public class Demo09Lambda {
  public static void printName(String name, PersonBuilder builder) {
      System.out.println(builder.buildPerson(name).getName());
  }
  public static void main(String[] args) {
          printName("赵丽颖", name ‐> new Person(name)); 
   }
}

2.6 数组的构造器引用
数组也是 Object 的子类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使用场景中时，需要一个函数式接口：

@FunctionalInterface 
public interface ArrayBuilder {
    int[] buildArray(int length);
 }

在应用该接口的时候，可以通过Lambda表达式：

public class Demo11ArrayInitRef {
        private static int[] initArray(int length, ArrayBuilder builder) {
        return builder.buildArray(length); 
        }
        public static void main(String[] args) { 
        int[] array = initArray(10, length ‐> new int[length]);
         }
 }

但是更好的写法是使用数组的构造器引用：

public class Demo12ArrayInitRef {
     private static int[] initArray(int length, ArrayBuilder builder) {
             return builder.buildArray(length);
     }
     public static void main(String[] args) { 
             int[] array = initArray(10, int[]::new);
     }
}

在这个例子中，下面两种写法是等效的：
Lambda表达式： length -> new int[length]
方法引用： int[]::new

备注：数组的构造器引用，可以和Java 8的Stream API结合，在一定程度上“解决”集合中 toArray 方法的泛型擦除问题。

程序员阿超

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Lambada表达式之初入江湖

1.1概念函数式接口在Java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类
复制链接

扫一扫