Android advanced Kotlin high-order functions and Lambda expressions detailed explanation

[[415968]]

Preface

Lambda syntax has been widely used in Java. We also integrate Lambda plug-ins into almost every project we develop on Android, because Lambda can indeed reduce the amount of code.

Coincidentally, Kotlin also has Lambda syntax. This article will explain in detail how to write and use Lambda syntax.

1. Detailed explanation of Kotin high-order functions

1. A higher-order function is a function that takes a function as an argument or return value. A good example of such a function is lock(), which accepts a lock object and a function, acquires the lock, runs the function, and releases the lock:

 fun <T> lock(lock: Lock, body: () -> T): T {
 lock.lock()
 try {
 return body()
 }
 finally {
 lock.unlock()
 }
 }

body has function type: () -> T, so it should be a function that takes no arguments and returns a value of type T. It is called inside the try{: .keyword }-block, protected by lock, and its result is returned by the lock() function. If we want to call the lock() function, we can pass another function to it as an argument (see function reference)

2. If a function receives another function as a parameter, or the type of the return value is another function, then the function is called a higher-order function

Function type, the basic rules are as follows:

(String,Int) -> Unit

Now add the above function type to the parameter declaration or return value declaration of a function, then this function becomes a higher-order function, for example

fun example(func: (String, Int) -> Unit) {

func("hello", 123)

}

You can see that the example() function here receives a function type parameter, so the example() function is a higher-order function;

Here I am going to define a higher-order function called num1AndNum2(), which accepts two integer and one function type parameters. In the num1AndNum2() function, we will perform some operation on the two integer parameters passed in and return the result. But the specific operation is determined by the function type parameter passed in.

Create a new file named Test1.kt

 fun num1AndNum2(num1: Int ,num2: Int ,operation:( Int , Int )-> Int ): Int {
    val result = operation(num1,num2)
 return result
 }
 fun plus(num1: Int , num2: Int ): Int {
 return num1 + num2
 }
 fun minus(num1: Int , num2: Int ): Int {
 return num1 - num2
 }
 main() function
 fun main(){
 val num1 = 100
 val num2 = 80
    val result1 = num1AndNum2(num1,num2, ::plus)
    val result2 = num1AndNum2(num1,num2,::minus)
    println( "result1:" +result1)
    println( "result2:" +result2)
 }
 result1:180
 result1:20

The writing of ::plus and ::minus is a function reference, which means passing the plus() and minus() functions as parameters to the num1AndNum2() function.

If every time you call any higher-order function, you have to define a function that matches its function type parameter, isn't it too complicated? That's right, so Kotlin also supports many other ways to call higher-order functions, such as Lambda expressions, anonymous functions, member references, etc. Lambda expressions are the most common and most popular way to call higher-order functions. The code just now uses Lambda expressions to implement (the last line of the Lambda expression is automatically used as the return value), and the plus() and minus() functions can be deleted.

 fun main() {
 val num1 = 100
 val num2 = 80
    val result1 = num1AndNum2(num1, num2) { n1, n2 ->
 n1 + n2
 }
    val result2 = num1AndNum2(num1, num2) { n1, n2 ->
 n1 - n2
 }
    println( "result1:" + result1)
    println( "result2:" + result2)
 }
 fun num1AndNum2(num1: Int , num2: Int , operation: ( Int , Int ) -> Int ): Int {
    val result = operation(num1, num2)
 return result
 }

3. Closure function

The return value of a function is a function, and the function contains another function inside, which can be an anonymous function with or without parameters.

 fun main(args: Array<String>) {
 val mm = aaa()
 println(mm())
 println(mm())
 println(mm())
 println(mm())
 println(mm())
 val kk = bbb()
    println(kk( "shadow" )) //shadow --- 1  
    println(kk( "shadow" )) //shadow --- 2  
    println(kk( "shadow" )) //shadow --- 3  
    println(kk( "shadow" )) //shadow --- 4  
    println(kk( "shadow" )) //shadow --- 5  
 }
 //The closure function is the function as the return parameter
 fun aaa(): () -> ( Int ) {
 var current = 10
 return fun(): Int {
 return   current ++
 }
 }
 fun bbb(): (String) -> (String) {
 var current = 0;
 return fun(str: String): String {
 current ++;
 return   "$str --- $current" ;
 }
 }

4. Kotin high-order function examples

Map Transformation

 fun main(args: Array<String>) {
    val list = listOf(1, 2, 3, 4, 5, 6)
 val newList = list.map {
 //Operate the data in the collection and assign it to the new collection
 (it * 2).toString()
    }.forEach(::println) //2 4 6 8 10 12
    val doubleList = list.map {
 it.toDouble()
    }.forEach(::print) //1.0 2.0 3.0 4.0 5.0 6.0
 //The second way to call the function as a parameter class name:: method name
    val doubleList2 = list.map( Int ::toDouble).forEach(::print) ////1.0 2.0 3.0 4.0 5.0 6.0
 }

flatMap transforms a collection of collections

 fun main(args: Array<String>) {
 val list = arrayOf(
 1..5,
 50..55
 )
 //Convert multiple array sets into one array and transform the data
 val mergeList = list.flatMap { intRange -> //set within a set 1..5 , 50..55
 intRange.map { intElement -> //Traversal of collection within collection 1,2,3,4,5
 "No.$intElement"  
 }
 }
    // No .1 , No .2 , No .3 , No .4 , No .5 , No .50 , No .51 , No .52 , No .53 , No .54 , No .55 ,
    mergeList.forEach { print( "$it , " ) }
 println()
 //Directly transform multiple array sets into a node set
    val newList = list.flatMap {
 it
 }
    //1 , 2 , 3 , 4 , 5 , 50 , 51 , 52 , 53 , 54 , 55 ,
    newList.forEach { print( "$it , " ) }
 }

filter

 fun main(args: Array<String>) {
 val list = arrayOf(
 1..5,
 2..3
 )
    val newList = list.flatMap {
 it
 }
 //Filter items with data > 2 in the collection
    val filterList = newList.filter { it > 2 }
    filterList.forEach(::print) //3453
 //Filter the items whose subscripts are odd in the collection
    val filterIndexList = newList.filterIndexed { index , i -> index % 2 == 0; }
    filterIndexList.forEach { print(it) } //1 3 5 3
 }

forEach

 fun main(args: Array<String>) {
    var list = listOf(1, 2, 3, 4, 5, 6)
 list.forEach(::println)
    val newList = arrayListOf<String>() --->1,2,3,4,5,6  
 list.forEach {
        newList. add ((it * 2).toString()) --->2,4,6,8,10,12  
 }
    newList.forEach(::println)
 }

Next, we will introduce Lambda

2. Lambda Expression Detailed Explanation

1. What is Lambda Expression?

• Lambda expression is an important new feature introduced by JDK8. Although it looks very impressive, the essence of Lambda expression is just a "syntactic sugar". If you are used to the idea of ​​object-oriented programming, you may not be used to this syntax at first. But if you have learned C#, you will find that the syntax is very similar to the "delegate" in C#.
• As we all know, everything in Java is an object. Java has always been committed to maintaining its object-first feature. Although functions are important to Java, in the Java world, functions cannot exist independently and can only rely on objects to call. In functional programming languages, functions are first-class citizens. They can exist independently. You can assign them to a variable or pass them as parameters to other functions. JavaScript is the most typical representative of functional programming languages;
• Functional languages ​​provide a powerful feature - closures, which have many advantages over traditional programming methods. Closures are callable objects that record some information from the scope in which they are created. Therefore, the closest concept to closures provided by Java is Lambda expressions. Although there are significant differences between closures and Lambda expressions, at least Lambda expressions are a good substitute for closures.
• The purpose of using Lambda expressions is to replace most anonymous inner classes, so that we can write more concise and elegant Java code, especially in the traversal of collections and other collection operations, which can greatly optimize the code structure. JDK also provides a large number of built-in functional interfaces for us to use, making the use of Lambda expressions more convenient and efficient;
• If you are not proficient in Lambda expressions, it is not recommended to use them indiscriminately, because you can also achieve the corresponding functions without using Lambda expressions. Just treat it as a tool to add icing on the cake.

2. Lambda expression syntax

The basic syntax structure of Lambda expressions is as follows:

 (parameters) -> expression
 or
 (parameters) ->{ statements; }

Among them, () is used to describe the parameter list, {} is used to describe the method body, -> is the lambda operator, read as (goes to), parameters represents parameters, expression represents expression, and statements represents code blocks.

The structure is described as follows:

A lambda expression can have zero or more parameters.

The types of parameters can be either explicitly stated or inferred from the context.

For example:

(int a) has the same effect as (a)

All parameters must be enclosed in parentheses and separated by commas.

For example:

 (a, b) or ( int a, int b) or (String a, int b, float c)

Empty parentheses indicate an empty parameter set. For example: () -> 42

When there is only one parameter and its type can be inferred, the parentheses () can be omitted.

For example: a -> return a*a

The body of a lambda expression can contain zero or more statements.

If the body of a Lambda expression has only one statement, the curly braces {} can be omitted. The return type of the anonymous function is consistent with the body expression;

If the body of a Lambda expression contains more than one statement, the expression must be contained in curly braces {} (forming a code block). The return type of the anonymous function is consistent with the return type of the code block, or null if there is no return;

3. Important features of Lambda expressions

• Optional type declaration: There is no need to declare parameter types, and the compiler can uniformly identify parameter values.
• Optional parameter parentheses: One parameter does not need to define parentheses, but multiple parameters do.
• Optional curly braces: If the body contains a single statement, no curly braces are required.
• Optional return keyword: If the body has only one expression that returns a value then the compiler will automatically return that value. The curly braces are required to specify that the expression returns a value.

4. Detailed explanation of functional interface

①What is a functional interface?

A functional interface in Java refers to an interface with only one abstract method.

Functional interface is an interface suitable for functional programming scenarios. Functional programming in Java is reflected in Lambda, so functional interface is an interface that can be used by lambda. Only when there is one and only one abstract method in the interface can lambda be deduced smoothly;

②Grammar

@FunctionalInterface annotation

The annotation is similar to the @override annotation and is applied to the definition of a functional interface.

Once this annotation is used to define a functional interface, the compiler will check whether the interface has one and only one abstract method.

 @FunctionalInterface
 public interface MyFunctionalInterface {
 void myMethod();
 }
 Using functional interfaces as method parameters
 public class Demo {
    private static void dos(FunctionInterface fi){
 fi.method();
 }
 public   static void main(String[] args) {
 Demo.dos(()->{System. out .println( "lambda expression" );});
 }

5. Basic use cases of Lambda expressions

Basic use cases of expressions

 // 1. No parameters are required, the return value is 5
 () -> 5
 // 2. Receive a parameter (number type) and return twice its value
 x -> 2 * x
 // 3. Accept 2 parameters (numbers) and return their difference
 (x, y) -> x – y
 // 4. Receive 2 int integers and return their sum
 ( int x, int y) -> x + y
 // 5. Accept a string object and print it in the console, without returning any value (it looks like void)
 (String s) -> System. out .print(s)
 Define 6 interfaces. We will demonstrate cases based on these 6 interfaces later.
 /**Multiple parameters have no return*/

 @FunctionalInterface
 public interface NoReturnMultiParam {
    void method( int a, int b);
 }
 /**No parameters, no return value*/
 @FunctionalInterface
 public interface NoReturnNoParam {
 void method();
 }
 /**One parameter has no return*/
 @FunctionalInterface
 public interface NoReturnOneParam {
 void method( int a);
 }
 /**Multiple parameters have return values*/
 @FunctionalInterface
 public interface ReturnMultiParam {
 int method( int a, int b);
 }
 /** No parameters but return*/
 @FunctionalInterface
 public interface ReturnNoParam {
 int method();
 }
 /**A parameter has a return value*/
 @FunctionalInterface
 public interface ReturnOneParam {
 int method( int a);
 }
 Example code:
 public class Test2 {
 public   static void main(String[] args) {
 //1. Simplify the parameter type. You can omit the parameter type, but you must omit all parameters.
        NoReturnMultiParam lamdba1 = (a, b) -> {
 System. out .println( "Simplified parameter type" );
 };
 lamdba1.method(1, 2);
 //2. Simplify the parameter brackets. If there is only one parameter, the parameter brackets can be omitted
        NoReturnOneParam lambda2 = a -> {
 System. out .println( "Simplified parameter parentheses" );
 };
 lambda2.method(1);
 //3. Simplify the method body braces. If the method has only one statement, the method body braces can be omitted, similar to if or for  
 NoReturnNoParam lambda3 = () -> System. out .println( "Simplified method body braces" );
 lambda3.method();
 //4. If the method body has only one statement and it is a return statement, the method body braces can be omitted
        ReturnOneParam lambda4 = a -> a+3;
        System. out .println(lambda4.method(5));
        ReturnMultiParam lambda5 = (a, b) -> a+b;
        System. out .println(lambda5.method(1, 1));
 }
 }

6. Use lambda expressions to reference methods

① The syntax for referencing a method is: method owner:: method name

Note: The static method belongs to the class name, and the common method belongs to the object. This code example combines the custom functional interface at the top:

 public class Exe1 {
 public   static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System. out .println(lambda1.method(3));
 //lambda2 references the already implemented doubleNum method
        ReturnOneParam lambda2 = Exe1::doubleNum;
        System. out .println(lambda2.method(3));
        Exe1 exe = new Exe1();
 //lambda4 references the already implemented addTwo method
        ReturnOneParam lambda4 = exe::addTwo;
        System. out .println(lambda4.method(2));
 }
 /**
     * Require
 * 1. The number and type of parameters must be consistent with those defined in the interface
 * 2. The return value type must be consistent with that defined in the interface
 */
 public   static   int doubleNum( int a ) {
 return a * 2;
 }
 public   int addTwo( int a ) {
 return a + 2;
 }
 }

②Constructor reference

Generally, we need to declare an interface, which serves as an object generator, instantiates an object through the class name::new, and then calls a method to return the object.

 interface ItemCreatorBlankConstruct {
 Item getItem();
 }
 interface ItemCreatorParamContruct {
    Item getItem( int id, String name , double price);
 }
 public class Exe2 {
 public   static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();
        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();
        ItemCreatorParamContruct creator3 = Item::new;
 Item item3 = creator3.getItem(119, "computer" , 5888.88);
 }
 }

One major difference between using anonymous classes and Lambda expressions is the use of keywords.

For anonymous classes, the keyword this is interpreted as the anonymous class, and for lambda expressions, the keyword this is interpreted as the outer class in which the lambda is written.

7. Lambda Summary Again

• Function type with no parameters and no return value (Unit return type cannot be omitted): () -> Unit;
• Function type that receives a parameter of type T and has no return value: (T) -> Unit;
• Function type that receives parameters of type T and type A and has no return value (same for multiple parameters): (T, A) -> Unit;
• A function type that takes a parameter of type T and returns a value of type R: (T) -> R;
• Function type that receives parameters of type T and type A and returns a value of type R (same for multiple parameters): (T, A) -> R;
• In the method implementation in curly braces {}, if there is only one parameter, you can use it to specify it without writing x->...;
• If there are multiple parameters in the method implementation, you need to specify the custom parameter name after -> in this way;

Summarize

1. Lambda and higher-order functions are a bit confusing to understand, and require a lot of practice and experimentation to slowly understand

2. Lambda is very deep. Let’s learn and improve together.