另外的Lambda文章：
https://baijiahao.baidu.com/s?id=1707435579480830206&wfr=spider&for=pc
https://www.freesion.com/article/55591228056/
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));
//声明一个List集合
List<Person> list = new ArrayList();
list.add(new Person("1001", "小A"));
list.add(new Person("1002", "小B"));
list.add(new Person("1003", "小C"));
System.out.println(list);
//将list转换map
Map<String, String> map = list.stream().collect(Collectors.toMap(Person::getId,Person::getName));
Map<String, ParamCalcrate> paramCalcrateMap = paramCalcrates.stream().collect(Collectors.toMap(paramCalcrate -> paramCalcrate.getTpId(), Function.identity()));
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));
1.9 Lambda中直接返回List
List<xxxx> returnCpList = cpList.stream().map(item->{
xxxx cp = new xxxx();
cp.setCpkPath(xxxx);
return cp;
}).collect(Collectors.toList());
1.10 Lambda中通过list过滤出结果，返回List
/**
* @author tuzuoquan
* @date 2022/5/6 11:06
*/
public class Book {
private String id;
private String name;
public Book() {}
public Book(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* TODO
*
* @author tuzuoquan
* @date 2022/5/6 11:07
*/
public class Demo {
public static List<Book> prepareData() {
//准备书的列表，id是从1到10
List<Book> bookList = new ArrayList<>();
for(int i = 1; i < 11; i++) {
bookList.add(new Book(String.valueOf(i),"book"+i));
}
return bookList;
}
public static void main(String[] args) {
List<Book> bookList = prepareData();
//要被找出的书的ID
ArrayList<String> ids = new ArrayList<>();
ids.add("3");
ids.add("6");
ids.add("8");
ids.add("9");
//存放过滤结果的列表
List<Book> result = null;
//使用lambda表达式过滤出结果并放到结果列表里，由zhangchao编写
result = bookList.stream().filter((Book b) -> ids.contains(b.getId())).collect(Collectors.toList());;
//打印结果列表
if(result != null && !result.isEmpty()){
result.stream().forEach(r -> System.out.println(r.getId() + " " + r.getName()));
}
}
}
输出结果：
3 book3
6 book6
8 book8
9 book9
1.12 将List转换成Map
List<Demo> demoList = demoMapper.getXxxxxx();
//构造map<String,List<Demo>>的数据结构，key是job_id
Map<Integer, List<Demo>> demoMap = demoList.stream().collect(Collectors.groupingBy(Demo::getId));
1.13 List排序
List<xxxx> versions = xxxMapper.listByJobId(jobId);
// 按照提交时间排序
versions = versions.stream()
.sorted((x, y) -> y.getEditTime().compareTo(x.getEditTime()))
.collect(Collectors.toList());
1.14 queue的迭代，排序等
Queue<CategoryPojo> queue = new PriorityQueue<>(3, //初始容量
//正常的排序,就是小的在前,大的在后,也就是c1>c2的时候返回1,也就是升序,也就是小顶堆
(c1, c2) -> c1.getTotalPrice() >= c2.getTotalPrice() ? 1 : -1);
//代码走到这里那么queue存放的就是分类的销售额top3,但是是升序.需要改为逆序然后输出
List<String> top3List = queue.stream()
.sorted((c1, c2) -> c1.getTotalPrice() >= c2.getTotalPrice() ? -1 : 1)
.map(c -> "分类:" + c.getCategory() + " 金额:" + c.getTotalPrice())
.collect(Collectors.toList());
1.15. map迭代
map.entrySet().stream().forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
1.16 list的过滤方式
public List<KernelConfig> productKernel(String product){
List<KernelConfig> kernels = xxxxx.xxxxx();
Map<Integer, List<String>> kernelList = xxxx();
// 过滤一下私有内核
return kernels.stream().filter(
k -> {
if(!kernelList.containsKey(k.getKernelId())){
return true;
}
List<String> productList = kernelList.get(k.getKernelId());
return productList == null || productList.contains(product);
}
).collect(Collectors.toList());
}
1.17 将list转成set
Set<Integer> kernelIdSet = kernels.stream().map(KernelConfig::getKernelId).collect(Collectors.toSet());
1.18. 如何将List按照指定的数字类型的字段升序排序
可以使用Java 8中的Stream API和Comparator来对List按照指定数字类型的字段进行升序排序。假设要按照num字段排序，可以使用以下代码：
List<Demo> demos = ...; // 原始的Demo列表
demos.sort(Comparator.comparingInt(Demo::getNum));
如果要按照其他数字类型的字段进行排序，可以使用相应的comparing方法，如comparingLong或comparingDouble。如果要进行降序排序，可以使用reversed方法，例如：
demos.sort(Comparator.comparingDouble(Demo::getScore).reversed());
2. Lambda表达式forEach如何跳出循环
lambda表达式大家都经常用，今天在用foreach循环的时候有一个逻辑判断需要跳出循环，但是lambda表达式不能用break也不能用continue，只有return可以用，但是用了之后发现，lambda表达式foreach的return和普通foreach循环的continue效果是一样的，如下：
那lambda表达式的foreach要怎么跳出循环呢？下面推荐两个方式，亲测有效。
方式一：可以使用anyMatch()方法，anyMatch()里接收一个返回值为boolean类型的表达式，只要返回true就会终止循环，这样可以将业务逻辑写在返回判断结果前。
方式二：可以使用filter()方法，思路是一样的，其中findAny表示只要找到满足的条件时停止。
虽然找到跳出循环的方法，但是其实普通foreach循环的性能会比lambda表达式要好一些，所以最后我又改回使用普通的foreach循环。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
