当前位置：网站首页>lambda expression

lambda expression

2022-07-29 22:35:00 【51CTO】

lambda表达式是java8A new new feature has been introduced,类似于js中的闭包,The purpose is to provide a functional programming-like syntax to simplify our coding

一,lambda基本语法

其实lambdaThe expression is very similar to the original method of writing a method.,只是,lambdaExpressions can make our original approach simpler to code,更加清晰明了

基本结构：

       
       //(方法参数) -> 方法体
       
(
       
       args)
       
       ->
       
       body
      
1.
2.

Common basic spelling can have：

       
       /**
       
       * 1. When the parameter type can be deduced,不需要指定类型,如 (a) -> System.out.println(a)
       
       * 2. When there is only one parameter and the type is deduced,不强制写 (), 如 a -> System.out.println(a)
       
       * 3. When the parameter specifies the type,必须有括号,如 (int a) -> System.out.println(a)
       
       * 4. 参数可以为空,如 () -> System.out.println(“hello”)
       
       * 5. body 需要用 {} 包含语句,当只有一条语句时 {} 可省略
       
       */
       
(
       
       a) 
       
       -> 
       
       a 
       
       * 
       
       a
       
(
       
       int 
       
       a, 
       
       int 
       
       b) 
       
       -> 
       
       a 
       
       + 
       
       b
       
(
       
       a, 
       
       b) 
       
       -> {
       
       return 
       
       a 
       
       - 
       
       b;}
       
() 
       
       -> 
       
       System.
       
       out.
       
       println(
       
       Thread.
       
       currentThread().
       
       getId())
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

二,函数式接口

java中的lambdaExpressions are based on functional interfaces

什么是函数式接口？

函数式接口（FunctionalInterface)就是只有一个方法的接口,The purpose of this type of interface is to perform a single operation,These functional interfaces are generally [email protected]

EG:

Usually we create threads usingRunnable接口就是一个函数式接口

The original way of creating threads：

       
       public 
       
       static 
       
       void 
       
       main(
       
       String[] 
       
       args) {
       
       new 
       
       Thread(
       
       new 
       
       Runnable() {
       
       @Override
       
       public 
       
       void 
       
       run() {
       
       System.
       
       out.
       
       println(
       
       "没有使用lambda表达式");
       
            }
       
        }).
       
       start();
       
    }
      
1.
2.
3.
4.
5.
6.
7.
8.

接下来我们使用lambda表达式创建线程：

       
       new 
       
       Thread(()
       
       ->
       
       System.
       
       out.
       
       println(
       
       "使用lambda表达式创建线程")).
       
       start();
      
1.

Is it simpler and clearer?

注意看Thread的参数,It turns out that we need to pass aRunableImplementing classes or writing methods as anonymous inner classes,但是现在,我们可以使用lambdaexpressions as function arguments,由此可见,Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

Earlier we wrote a pressjsonArrayA way to sort a field,But the comparator in this method is written in the traditional way,现在我们来用lambda试着简化一下：

原函数：

       
       /**
       
       * 对json数组排序,
       
       * @param jsonArr
       
       * @param sortKey 排序关键字
       
       * @param is_desc is_desc-falseascending sequence is_desc-true降序 (Sort field as string)
       
       * @return
       
       */
       
       public 
       
       static 
       
       String 
       
       jsonArraySort(
       
       JSONArray 
       
       jsonArr, 
       
       String 
       
       sortKey, 
       
       boolean 
       
       is_desc) {
       
       JSONArray 
       
       sortedJsonArray 
       
       = 
       
       new 
       
       JSONArray();
       
       List
       
       <
       
       JSONObject
       
       > 
       
       jsonValues 
       
       = 
       
       new 
       
       ArrayList
       
       <
       
       JSONObject
       
       >();
       
       for (
       
       int 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       jsonArr.
       
       size(); 
       
       i
       
       ++) {
       
       jsonValues.
       
       add(
       
       JSONObject.
       
       parseObject(
       
       String.
       
       valueOf(
       
       jsonArr.
       
       getJSONObject(
       
       i))));
       
        }
       
       Collections.
       
       sort(
       
       jsonValues, 
       
       new 
       
       Comparator
       
       <
       
       JSONObject
       
       >() {
       
       private  
       
       final 
       
       String 
       
       KEY_NAME 
       
       = 
       
       sortKey;
       
       @Override
       
       public 
       
       int 
       
       compare(
       
       JSONObject 
       
       a, 
       
       JSONObject 
       
       b) {
       
       String 
       
       valA 
       
       = 
       
       new 
       
       String();
       
       String 
       
       valB 
       
       = 
       
       new 
       
       String();
       
       try {
       
       valA 
       
       = 
       
       a.
       
       getString(
       
       KEY_NAME);
       
       valB 
       
       = 
       
       b.
       
       getString(
       
       KEY_NAME);
       
                } 
       
       catch (
       
       JSONException 
       
       e) {
       
       e.
       
       printStackTrace();
       
                }
       
       if (
       
       is_desc){
       
       return 
       
       -
       
       valA.
       
       compareTo(
       
       valB);
       
                } 
       
       else {
       
       return 
       
       -
       
       valB.
       
       compareTo(
       
       valA);
       
                }
       
            }
       
        });
       
       for (
       
       int 
       
       i 
       
       = 
       
       0; 
       
       i 
       
       < 
       
       jsonArr.
       
       size(); 
       
       i
       
       ++) {
       
       sortedJsonArray.
       
       add(
       
       jsonValues.
       
       get(
       
       i));
       
        }
       
       return 
       
       sortedJsonArray.
       
       toString();
       
    }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

使用lambda表达式简化代码：

       
       /**
       
       * 对json数组排序,
       
       * @param jsonArr
       
       * @param sortKey 排序关键字
       
       * @param is_desc is_desc-falseascending sequence is_desc-true降序 (Sort field as string)
       
       * @return
       
       */
       
       public 
       
       static 
       
       String 
       
       jsonArraySort(
       
       JSONArray 
       
       jsonArr, 
       
       String 
       
       sortKey, 
       
       boolean 
       
       is_desc) {
       
       JSONArray 
       
       sortedJsonArray 
       
       = 
       
       new 
       
       JSONArray();
       
       List
       
       <
       
       JSONObject
       
       > 
       
       jsonValues 
       
       = 
       
       new 
       
       ArrayList
       
       <>();
       
       jsonArr.
       
       forEach(
       
       a
       
       ->
       
       jsonValues.
       
       add(
       
       JSONObject.
       
       parseObject(
       
       String.
       
       valueOf(
       
       a))));
       
       Collections.
       
       sort(
       
       jsonValues,(
       
       JSONObject 
       
       a, 
       
       JSONObject 
       
       b)
       
       ->{
       
       final 
       
       String 
       
       KEY_NAME 
       
       = 
       
       sortKey;
       
       String 
       
       valA 
       
       = 
       
       a.
       
       getString(
       
       KEY_NAME);
       
       String 
       
       valB 
       
       = 
       
       b.
       
       getString(
       
       KEY_NAME);
       
       if(
       
       is_desc){
       
       return 
       
       -
       
       valA.
       
       compareTo(
       
       valB);
       
            }
       
       else {
       
       return 
       
       valA.
       
       compareTo(
       
       valB);
       
            }
       
        });
       
       jsonArr.
       
       forEach(
       
       a 
       
       -> 
       
       sortedJsonArray.
       
       add(
       
       a));
       
       return 
       
       sortedJsonArray.
       
       toString();
       
    }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

JDK中的函数式接口
In order to directly use the existing class library Lambda 表达式,Java 8 Previously there were some interfaces that had been marked as functional interfaces：

java.lang.Runnable
java.util.Comparator
java.util.concurrent.Callable
java.io.FileFilter
java.security.PrivilegedAction
java.beans.PropertyChangeListener

Java 8 A new package has been added to the java.util.function,Brings commonly used functional interfaces：

Function<T, R> - 函数：输入 T 输出 R
BiFunction<T, U, R> - 函数：输入 T 和 U 输出 R 对象
Predicate - 断言/判断：输入 T 输出 boolean
BiPredicate<T, U> - 断言/判断：输入 T 和 U 输出 boolean
Supplier - 生产者：无输入,输出 T
Consumer - 消费者：输入 T,无输出
BiConsumer<T, U> - 消费者：输入 T 和 U 无输出
UnaryOperator - unit operation：输入 T 输出 T
BinaryOperator - 二元运算：输入 T 和 T 输出 T

Is also the basic types of function is increased the more specific interface,包括：BooleanSupplier, DoubleBinaryOperator, DoubleConsumer, DoubleFunction, DoublePredicate, DoubleSupplier, DoubleToIntFunction, DoubleToLongFunction, DoubleUnaryOperator, IntBinaryOperator, IntConsumer, IntFunction, IntPredicate, IntSupplier, IntToDoubleFunction, IntToLongFunction, IntUnaryOperator, LongBinaryOperator, LongConsumer, LongFunction, LongPredicate, LongSupplier, LongToDoubleFunction, LongToIntFunction, LongUnaryOperator, ToDoubleBiFunction<T, U>, ToDoubleFunction, ToIntBiFunction<T, U>, ToIntFunction, ToLongBiFunction<T, U>, ToLongFunction .Combined with the above functional interface,To these basic types of functional interface by the name of the class can see the effect of the interface

Throughout the above functional interface,In fact, it can be divided into four categories：