函数式编程Stream流（一）--Lambda表达式
1.概述
1.1为什学？
- 能够看懂公司的代码
- 大数量下处理集合效率高
- 代码可读性高
- 消灭嵌套地狱
// 查询未成年作家的评分在70分以上的著作， 由于洋流影响所以作家和著作可能出现重复，需要进行去重
List<Book> bookList = new ArrayList<>();
Set<Book> uniqueBookValues = new HashSet<>();
Set<Author> uniqueAuthorValues = new HashSet<>();
for (Author author : authors) {
if (uniqueAuthorValues.add(author)) {
List<Book> books = author.getBooks();
for (Book book : books) {
if (book.getScore() > 70) {
if (uniqueBookValues.add(book)) {
bookList.add(book);
}
}
}
}
}
System.out.print(bookList)
}
如果用函数式编程接口的实现如下，简洁很多
//TODO 等我学完了再来补充把；
1.2函数式编程思想
1.2.1概念
面向对象思想需要关注用什么对象完成什么事情，不关注对象。而函数式编程思想就类似于我们数学中的函数。它主要关注的是对数据进行了什么操作。
1.2.2优点
- 代码简洁，开发快熟
- 接近自然语言，易于理解
- 易于“并发编程”
2.Lambda表达式
2.1概述
Lambda是jdk8中的一个语法糖。
可以看成是一种语法糖，他可以对某些匿名内部类的写法进行简化。
他是函数式编程思想的一个重要体现。
2.2核心原则
可推导，可省略
2.3基本格式
(参数列表)->{代码}
例一
我们在创建线程并启动时候可以使用匿名内部类的写法：
new Thread(new Runnable(){
@Override
public void run(){
System.out.print("村长大人，你好呀~");
}
}).start()；
可以是用lambda表达式进行修改，修改后如下：
new Thread(()->{System.out.print("村长大人，你好呀~");}).start();
函数式接口，只有一个抽象方法的接口，关注这个方法的参数，以及要@Override（重写）的方法体
注意：刚刚开始，先使用匿名内部类的方法实现，后面重新翻译成Lambda表达式的格式；多多练习；
例二
现有方法定义如下,其中IntBinaryOperator是一个接口，先使用匿名内部类的写法调用该方法
public static int caculateNum(IntBinaryOperator operator) {
int a = 10;
int b = 20;
return operator.applyAsInt(a, b);
}
public static void main(String[] args) {
//idea 中alt +回车可以提示自动转换成lambda表达式
int result = caculateNum(new IntBinaryOperator() {
@Override
public int applyAsInt(int left, int right) {
return left + right;
}
});
System.out.println("result = " + result);
//我们只需要关注函数式接口中的**参数列表**和**方法体**
result = caculateNum((int left, int right) -> {
return left + right;
});
//return 和 {}在一些特殊场景下可以省略；
result = caculateNum((int left, int right) -> left + right);
System.out.println("result = " + result);
}
小技巧：idea中 alt+enter组合键，可以将lambda表达式和匿名内部类进行相互转换；
匿名内部类->lambda
lambda->匿名内部类
例三
现有方法定义如下，其中IntPredicate式一个接口。先使用匿名内部类的写法调用该方法
public static void printNum(IntPredicate predicate) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i : arr) {
if (predicate.test(i)) {
System.out.println(i);
}
}
}
//匿名内部类调用该方法
public static void main(String[] args) {
printNum(new IntPredicate() {
@Override
public boolean test(int value) {
//自定义方法体，我们可以用来判断value是否是偶数
return value % 2 == 0;
}
});
}
lambda写法：
printNum(value -> {
//自定义方法体，我们可以用来判断value是否是偶数
return value % 2 == 0;
});
printNum(value -> value % 2 == 0);
例四
现有方法定义如下,其中Function是一个接口。先使用匿名内部类的写法调用该方法
public static <R> R typeConver(Function<String, R> function) {
//Function 参数类型进行相互转换，左边的类型T ,转换为右边的参数类型R
String str = "12345";
R result = function.apply(str);
return result;
}
public static void main(String[] args) {
Integer integer = typeConver(new Function<String, Integer>() {
@Override
public Integer apply(String str) {
return Integer.valueOf(str);
}
});
System.out.println("integer = " + integer);
}
Lambda写法：
Integer integer = typeConver(str -> {
//把T类型String 转换成R 类型Integer，只要保证返回值的类型正确即可；
return Integer.valueOf(str);
});
System.out.println("integer = " + integer);
}
Integer integer = typeConver(str -> Integer.valueOf(str));`
例五
现有方法定义如下，其中IntConsumer 是一个接口。先使用匿名内部类的写法调用该方法
public static void forEachArr(IntConsumer consumer) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i : arr) {
consumer.accept(i);
}
}
public static void main(String[] args) {
forEachArr(new IntConsumer() {
@Override
public void accept(int value) {
System.out.println("value = " + value);
}
});
}
lambda写法如下：
forEachArr(value -> {
//没否返回值，对参数进行 操作，也算是一种消费
System.out.println("value = " + value);
});
forEachArr(value -> System.out.println("value = " + value));
2.4省略规则
- 参数类型可以省略
- 方法体只有一句代码时，大括号、return、和唯一一句代码的分号可以省略 可以省略
- 方法只有一个参数的时候，小括号可以省略
- 以上这些规则都记不住的话，也可以省略
