Lambda表达式

- 日理万妓 2022-09-05 00:06 12阅读 0赞

# 1.Lambda表达式 #

以下转自：https://www.runoob.com/java/java8-lambda-expressions.html

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。  
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。  
使用 Lambda 表达式可以使代码变的更加简洁紧凑。

**语法**  
lambda表达式的语法格式如下：

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

**以下是lambda表达式的重要特征：**  
**可选类型声明**：不需要声明参数类型，编译器可以统一识别参数值。  
**可选的参数圆括号**：一个参数无需定义圆括号，但多个参数需要定义圆括号。  
**可选的大括号**：如果主体包含了一个语句,就不需要使用大括号。  
**可选的返回关键字**：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

## 1.1.Lambda表达式实例 ##

**Lambda 表达式的简单例子：**

// 1. 不需要参数,返回值为 5 
    () -> 5  
      
    // 2. 接收一个参数(数字类型),返回其2倍的值 
    x -> 2 * x  
      
    // 3. 接受2个参数(数字),并返回他们的差值 
    (x, y) -> x – y  
      
    // 4. 接收2个int型整数,返回他们的和 
    (int x, int y) -> x + y
    
    //5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s);

**在 Demo1.java 文件输入以下代码：**

package project;
    
    public class Demo1 { 
    
    	public static void main(String[] args) { 
    		Demo1 tester = new Demo1();
    		
    		// 类型声明
    	    MathOperation addition = (int a, int b) -> a + b;
    	        
    	    // 不用类型声明
    	    MathOperation subtraction = (a, b) -> a - b;
    	        
    	    // 大括号中的返回语句
    	    MathOperation multiplication = (int a, int b) -> {  return a * b; };
    		
    	    //没有大括号及返回语句
    	    MathOperation division = (int a, int b) -> a / b;
    	    
    	    System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
    	    System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
    	    System.out.println("10 * 5 = " + tester.operate(10, 5, multiplication));
    	    System.out.println("10 / 5 = " + tester.operate(10, 5, division));
    	    
    	    //不用括号
    	    GreetingService greetingService1 = message ->
    	    System.out.println("Hello " + message);
    	    
    	    //用括号
    	    GreetingService greetingService2 = (message) ->
    	    System.out.println("Hello " + message);
    	    
    	    greetingService1.sayMessage("Runoob");
    	    greetingService2.sayMessage("Google");
    	    
    	}
    
    	interface MathOperation { 
    		int operation(int a, int b);
    	}
    
    	interface GreetingService { 
    		void sayMessage(String message);
    	}
    
    	private int operate(int a, int b, MathOperation mathOperation) { 
    		return mathOperation.operation(a, b);
    	}
    	
    }

**执行以上脚本，输出结果：**

10 + 5 = 15
    10 - 5 = 5
    10 * 5 = 50
    10 / 5 = 2
    Hello Runoob
    Hello Google

**使用Lambda表达式需要注意以下两点：**  
Lambda表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。  
Lambda表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

## 1.2.变量作用域 ##

lambda表达式只能引用标记了 final 的外层局部变量，这就是说不能在lambda内部修改定义在域外的局部变量，否则会编译错误。

**在Demo2.java文件输入以下代码:**

public class Demo2 { 
    
    	final static String salutation = "Hello! ";
    	
    	public static void main(String[] args) { 
    		GreetingService greetService1 = message ->
    		System.out.println(salutation + message);
    		greetService1.sayMessage("Runoob");
    	}
    	
    	interface GreetingService { 
    		void sayMessage(String message);
    	}
    	
    }

执行以上脚本，输出结果为：

Hello! Runoob

## 1.3.Lambda 表达式的来对集合进行遍历 ##

代码示例如下：

package project;
    
    import java.util.Arrays;
    import java.util.function.Consumer;
    
    public class Demo3 { 
    
    	public static void main(String[] args) { 
    		//使用Lambda表达式
    		Arrays.asList(1,2,3).forEach(element -> System.out.println(element));
    		
    		System.out.println("----------------------------------");
    		
    		//使用匿名内部类
    		Arrays.asList(1,2,3).forEach(new Consumer<Integer>() { 
    
    			@Override
    			public void accept(Integer integer) { 
    				System.out.println(integer);
    			}
    			
    		});
    	}
    	
    }

**输出结果：**

1
    2
    3
    ----------------------------------
    1
    2
    3

**Lambda表达式语法如下：**  
用逗号分隔的形式参数列表，用括号括起来。  
**Note**: 数据类型可以省略，只有一个参数还可以省略括号，例如，上图的**element**。

标识符：->  
主体：放在\{\}内。  
**Note**:如果主体仅仅是一个表达式或者或一个语句块，\{\} 和 ; 可以省略。只存在单条返回语句的话，return 关键字也可以省略。

**我们对集合进行遍历，做一个完整的演进：**

package project;
    
    import java.util.Arrays;
    import java.util.function.Predicate;
    
    public class Demo4 { 
    
    	public static void main(String[] args) { 
    		//完整形式
    		Arrays.asList(1,2,3).stream().allMatch((Integer element) -> { 
    			return element > 0;
    		});
    		
    		//省略 数据类型,()
    		Arrays.asList(1,2,3).stream().allMatch(element -> { 
    			return element > 0;
    		});
    		
    		//省略 数据类型，()以及{},return 和;
    		Arrays.asList(1,2,3).stream().allMatch(element -> element > 0);
    		
    		//外部定义 Lambda 表达式
    		Predicate<Integer> predicate = element -> element > 0;
    		Arrays.asList(1,2,3).stream().allMatch(predicate);
    	}
    	
    }

不过，Lambda 表达式只能用于功能接口（函数式接口），也就是说只能用在一个接口除了含有单个抽象方法和 Object 中的 public 访问修饰符定义的方法外，不能再含有其它抽象方法。Java中常见的Comparator便是一个很好的例子。

## 1.4.Lambda表达式的结构 ##

让我们了解一下Lambda表达式的结构。  
一个 Lambda 表达式可以有零个或多个参数。  
参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同。  
所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)  
空圆括号代表参数集为空。例如：() -> 42  
当只有一个参数，且其类型可推导时，圆括号()可省略。例如：a -> return a\*a  
Lambda 表达式的主体可包含零条或多条语句。  
如果Lambda表达式的主体只有一条语句,花括号\{\}可省略。匿名函数的返回类型与该主体表达式一致。  
如果Lambda表达式的主体包含一条以上语句,则表达式必须包含在花括号\{\}中（形成代码块）。匿名函数的返回类型与代码的返回类型一致，若没有返回则为空。

Java 中的 Lambda 表达式通常使用 (argument) -> (body) 语法书写，例如：

(arg1, arg2...) -> { body}
    (type1 arg1, type2 arg2...) -> { body}

**以下是一些 Lambda 表达式的例子：**

(int a, int b) -> {   return a + b; }
    () -> System.out.println("Hello World");
    (String s) -> {  System.out.println(s); }
    () -> 42
    () -> { return 3.1415};

## 1.5.map的使用 ##

package demo2;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class Demo1 { 
    
    	public static void main(String[] args) { 
    		List<String> list= Arrays.asList("a", "b", "c", "d");
    
            //String::toUpperCase 表示string中的toUpperCase方法
    		List<String> collect =list.stream().map(String::toUpperCase).collect(Collectors.toList());
    		System.out.println(collect); //[A, B, C, D]
    
    		List<Integer> num = Arrays.asList(1,2,3,4,5);
    		List<Integer> collect1 = num.stream().map(n -> n * 2).collect(Collectors.toList());
    		System.out.println(collect1); //[2, 4, 6, 8, 10]
    	}
    	
    }

## 1.6.Java 8十个lambda表达式案例 ##

以下转自：https://www.jdon.com/idea/java/10-example-of-lambda-expressions-in-java8.html

### 1.6.1.实现Runnable线程案例 ###

使用() -> \{\} 替代匿名类：

package project;
    
    public class Demo5 { 
    
    	public static void main(String[] args) { 
    		new Thread(new Runnable() { 
    			
    			@Override
    			public void run() { 
    				System.out.println("Before Java8");
    			}
    			
    		}).start();
    		
    		new Thread( () -> System.out.println("In Java8!")).start();
    	}
    	
    }

### 1.6.2.实现事件处理 ###

如果你曾经做过Swing 编程，你将永远不会忘记编写事件侦听器代码。使用lambda表达式如下所示写出更好的事件侦听器的代码。

import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    
    public class Demo6 { 
    
    	public static void main(String[] args) { 
    		//Before Java 8:
    		JButton show = new JButton("Show");
    		
    		show.addActionListener(new ActionListener() { 
    			
    			@Override
    			public void actionPerformed(ActionEvent e) { 
    				System.out.println("without lambda expression is boring");
    			}
    		});
    		
    		// Java 8 way:
    		show.addActionListener((e) -> { 
    		    System.out.println("Action !! Lambda expressions Rocks");
    		});
    		
    	}
    	
    }

### 1.6.3.使用Lambda表达式遍历List集合 ###

import java.util.Arrays;
    import java.util.List;
    
    public class Demo7 { 
    
    	public static void main(String[] args) { 
    		// prior Java 8
    		List<String> features = Arrays.asList("Lambdas", "Default Method", 
    				"Stream API", "Date and Time API");
    		
    		for (String feature : features) { 
    			System.out.println(feature);
    		}
    		
    		System.out.println("===========================");
    		
    		// In Java 8
    // List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API",
    // "Date and Time API");
    		features.forEach(n -> System.out.println(n));
    		
    		System.out.println("===========================");
    		
    		// Even better use Method reference feature of Java 8
    		// method reference is denoted by :: (double colon) operator
    		// looks similar to score resolution operator of C++
    		
    		features.forEach(System.out::println);
    	}
    	
    }

方法引用是使用两个冒号::这个操作符号

输出结果：

Lambdas
    Default Method
    Stream API
    Date and Time API
    ===========================
    Lambdas
    Default Method
    Stream API
    Date and Time API
    ===========================
    Lambdas
    Default Method
    Stream API
    Date and Time API

### 1.6.4.使用Lambda表达式和函数接口 ###

为了支持函数编程，Java 8加入了一个新的包java.util.function，其中有一个接口java.util.function.Predicate是支持Lambda函数编程：

package demo2;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Predicate;
    
    public class Demo1 { 
    
    	public static void main(String[] args) { 
    		List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
    		System.out.println("Languages which starts with J:");
    		filter(languages, (str) -> str.startsWith("J"));
    		
    		System.out.println("--------------------------");
    		
    		System.out.println("Languages which ends with a ");
    		filter(languages, (str) -> str.endsWith("a"));
    		
    		System.out.println("--------------------------");
    		System.out.println("Print all languages: ");
    		filter(languages, (str) -> true);
    		
    		System.out.println("--------------------------");
    		System.out.println("Print no language: ");
    		filter(languages, (str)-> false);
    		
    		System.out.println("-------------------------");
    		System.out.println("Print language whose length greater than 4:");
    		filter(languages, (str)->str.length() > 4);
    	}
    	
    // public static void filter(List<String> names, Predicate<String> condition) { 
    // for(String name : names) { 
    // if (condition.test(name)) { 
    // System.out.println(name + " ");
    // }
    // }
    // }
    	
    	public static void filter(List<String> names, Predicate<String> condition) { 
    		names.stream().filter((name) -> (condition.test(name)))
    		    .forEach((name) -> { System.out.println(name + " ");});
    	}
    }

输出结果：

Languages which starts with J:
    Java 
    --------------------------
    Languages which ends with a 
    Java 
    Scala 
    --------------------------
    Print all languages: 
    Java 
    Scala 
    C++ 
    Haskell 
    Lisp 
    --------------------------
    Print no language: 
    -------------------------
    Print language whose length greater than 4:
    Scala 
    Haskell

### 1.6.5.复杂的结合Predicate使用 ###

java.util.function.Predicate提供and(), or() 和 xor()可以进行逻辑操作，比如为了得到一串字符串中以"J"开头的4个长度：

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Predicate;
    
    public class Demo1 { 
    
    	public static void main(String[] args) { 
    		List<String> names = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
    		
    		// We can even combine Predicate using and(), or() And xor() logical functions
    		// for example to find names, which starts with J and four letters long, you
    		// can pass combination of two Predicate
    		Predicate<String> startsWithJ = (n) -> n.startsWith("J");
    		Predicate<String> fourLetterLong = (n) -> n.length() == 4;
    		
    		names.stream().filter(startsWithJ.and(fourLetterLong))
    		     .forEach((n) -> System.out.print("\nName,which starts with 'J' and four letter long is : " + n));
    		// 输出内容：Name,which starts with 'J' and four letter long is : Java
    	}
    	
    }

### 1.6.6.使用Lambda实现Map和Reduce ###

最流行的函数编程概念是map，它允许你改变你的对象，在这个案例中，我们将costBeforeTeax集合中每个元素改变了增加一定的数值，我们将Lambda表达式 x -> x\*x传送map()方法，这将应用到stream中所有元素。然后我们使用 forEach() 打印出这个集合的元素.

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo2 { 
    
    	public static void main(String[] args) { 
    // List<Integer> costBeforeTax = Arrays.asList(100,200,300,400,500);
    // 
    // for (Integer cost : costBeforeTax) { 
    // double price = cost + .12 * cost;
    // System.out.println(price);
    // }
    		
    		// With Lambda expression:
    		List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    		costBeforeTax.stream().map((cost) -> cost + .12*cost)
    		             .forEach(System.out::println);
    	}
    	
    }

**输出结果：**

112.0
    224.0
    336.0
    448.0
    560.0

reduce()是将集合中所有值结合进一个，Reduce类似SQL语句中的sum(),avg()或count(),

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Demo3 { 
    
    	public static void main(String[] args) { 
    		// Applying 12% VAT on each purchase
    		// Old way:
    // List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    // double total = 0;
    // for (Integer cost : costBeforeTax) { 
    // double price = cost + .12*cost;
    // total = total + price;
    // }
    // System.out.println("Total : " + total);
    		
    		//输出结果：Total :1680.0
    		
    		// New way:
    		List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    		double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost)
    				.reduce((sum, cost) -> sum + cost)
    				.get();
    		System.out.println("Total :" + bill);
    		
    		//输出结果：Total :1680.0
    	}
    	
    }

### 1.6.7.通过filtering创建一个字符串String的集合 ###

Filtering是对大型Collection操作的一个通用操作，Stream提供filter()方法，接受一个Predicate对象，意味着你能传送lambda表达式作为一个过滤逻辑进入这个方法：

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class Demo4 { 
    
    	public static void main(String[] args) { 
    		// Create a List with String more than 2 characters
    		List<String> strList = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
    		
    		List<String> filtered = strList.stream().filter(x -> x.length() > 2)
    				.collect(Collectors.toList());
    		System.out.printf("Original List:%s, filtered list : %s %n", strList, filtered);		
    	}
    	
    }
    
    //输出结果：
    Original List:[Java, Scala, C++, Haskell, Lisp], filtered list : [Java, Scala, C++, Haskell, Lisp]

### 1.6.8.对集合中每个元素应用函数 ###

我们经常需要对集合中元素运用一定的功能，如表中的每个元素乘以或除以一个值等等.

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class Demo5 { 
    
    	public static void main(String[] args) { 
    		List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany",
    				"Italy", "U.K.", "Canada");
    		String G7Countries = G7.stream().map(x->x.toUpperCase())
    				.collect(Collectors.joining(", "));
    		System.out.println(G7Countries);
    		// 输出结果： USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA
    	}
    	
    }

上面是将字符串转换为大写，然后使用逗号串起来。

### 1.6.9.通过复制不同的值创建一个子列表 ###

使用Stream的distinct()方法过滤集合中重复元素。

package demo3;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class Demo6 { 
    
    	public static void main(String[] args) { 
    		List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
    		List<Integer> distinct = numbers.stream().map(i -> i*i).distinct()
    				.collect(Collectors.toList());
    		System.out.printf("Original List : %s, Square Without duplicates :%s %n", 
    	    		numbers, distinct);
    		//输出结果：Original List : [9, 10, 3, 4, 7, 3, 4], Square Without duplicates :[81, 100, 9, 16, 49]
    	}
    	
    }

### 1.6.10.计算List中的元素的最大值，最小值，总和及平均值 ###

package demo3;
    
    import java.util.Arrays;
    import java.util.IntSummaryStatistics;
    import java.util.List;
    
    public class Demo7 { 
    
    	public static void main(String[] args) { 
    		//Get count, min, max, sum, and average for numbers
    		List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
    		IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x)
    		                                            .summaryStatistics();
    		System.out.println("Highest prime number in List : " + stats.getMax());
    		System.out.println("Lowest prime number in List : " + stats.getMin());
    		System.out.println("Sum of all prime numbers : " + stats.getSum());
    		System.out.println("Average of all prime numbers : " + stats.getAverage());
    		
    		//Highest prime number in List : 29
    		//Lowest prime number in List : 2
    		//Sum of all prime numbers : 129
    		//Average of all prime numbers : 12.9
    	}
    	
    }

## 1.7.将List转成Map结构数据 ##

Map<String, AlarmMeta> alarmMetaMap = alarmMetaMapper.getAll().stream().collect(Collectors.toMap(AlarmMeta::getJobId, meta -> meta));

转换方式二：

Map<String, List<JobHistoryModel>> jobHistoryModelListByJobType = jobHistoryModelList.stream().collect(Collectors.groupingBy(JobHistoryModel::getJobType));

## 1.8.Lambda中map方法的使用 ##

List<Integer> list = Arrays.stream(intArray).map(
                    Integer::valueOf
            ).collect(Collectors.toList());
    
    Map<String, List<JobHistoryModel>> jobHistoryModelListByJobType = jobHistoryModelList
            .stream()
            .filter(m -> jobStatusList.contains(m.getJobStatus()))
            .collect(Collectors.groupingBy(JobHistoryModel::getJobType));