目录
1、Lambda是什么？
可以把Lambda表达式理解为简洁的表示可传递的匿名函数的一种方式：它没有名称，但有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。
2、Lambda表达式组成部分是什么？
Lambda表达式由参数、箭头和主体组成。
Lambda基本语法：
(parameters) -> expression
或
(parameters) -> { statements; }
例子：
1. (String s) -> s.length()该表达式具有一个String类型的参数并返回一个int。没有return语句，因为已经隐含了return
2. (Apple a) -> a.getWeight() > 150该表达式具有一个Apple类型的参数并返回一个boolean。
3. () -> 42该表达式具有一个没有参数返回int。
4. (int x, int y) -> { System.out.println("Result:"); System.out.println(x+y); }该表达式具有两个int参数没有返回值（void返回）,Lambda表达式可以包含多行语句。
3、为什么要用以及在哪里可以使用Lambda？
从上一专题我们得知，Lambda表达式可以使代码更加的简洁易懂。再贴一个小例子：
//之前是这样做
Comparator<Apple> byWeight = new Comparator<Apple>() {
public int compare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight());
}
};
//使用Lambda后
Comparator<Apple> byWeight =
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
你可以在函数式接口上使用Lambda表达式。
4、 函数式接口
1）什么是函数式接口？
函数式接口就是只定义一个抽象方法的接口。
例如：我们在专题二中谈到的Comparator和Runnable。
//java.util.Comparator
public interface Comparator<T> {
int compare(T o1, T o2);
}
//java.lang.Runnable
public interface Runnable{
void run();
}
2）什么是函数描述符？
函数式接口的抽象方法的签名基本就是Lambda表达式的签名，我们将这种抽象方法叫做函数描述符。
例如 ，Runnable接口可以看作是一个什么也不接受什么也不返回（void）的函数的签名，因为它只有一个叫做run的抽象方法，这个方法什么也不接受，什么也不返回。
3）认识三个函数式接口Predicate、Consumer、Function
Predicate
//java.util.function.Predicate<T>接口定义了一个名叫test的抽象方法。
//它接收泛型T对象，并返回一个boolean。
//这就和你在专题二中创建的一样，现在可以直接使用了。
// code清单
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
//自定义filter方法
public static <T> List<T> filter(List<T> list, Predicate<T> p) {
List<T> results = new ArrayList<>();
for (T s : list) {
if (p.test(s)) {
results.add(s);
}
}
return results;
}
//使用方法
Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);
Consumer
//java.util.function.Consumer<T>定义了一个名叫accept的抽象方法。
//它接受泛型T的对象，没有返回（void）。
//你如果需要访问类型T的对象，并对其执行某些操作，就可以使用
//code清单
@FunctionalInterface
public interface Consumer<T>{
void accept(T t);
}
//自定义forEach方法
public static <T> void forEach(List<T> list, Consumer<T> c){
for(T i: list){
c.accept(i);
}
}
//如何使用
forEach(
Arrays.asList(1,2,3,4,5),
(Integer i) -> System.out.println(i)
);
Function
//java.util.function.Function<T, R>接口定义了一个叫作apply的方法。
//它接受一个泛型T的对象，并返回一个泛型R的对象。
//如果你需要定义一个Lambda，将输入对象的信息映射到输出，就可以使用这个接口。
@FunctionalInterface
public interface Function<T, R>{
R apply(T t);
}
//自定义map方法
public static <T, R> List<R> map(List<T> list,
Function<T, R> f) {
List<R> result = new ArrayList<>();
for(T s: list){
result.add(f.apply(s));
}
return result;
}
//将一个String列表映射到包含每个String长度的Integer列表。
List<Integer> l = map(
Arrays.asList("lambdas","in","action"),
(String s) -> s.length()
);
// 结果[7, 2, 6]
4）原始类型特化
IntPredicate可以避免装箱拆箱造成的性能代价。
public interface IntPredicate{
boolean test(int t);
}
IntPredicate evenNumbers = (int i) -> i % 2 == 0;
//true(无装箱)
evenNumbers.test(1000);
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
//false(装箱)
oddNumbers.test(1000);
Java8中还提供了以下函数式接口：
5、 方法引用
方法引用就是Lambda表达式的一个语法糖，让你可以重复使用现有的方法定义，并像Lambda一样 传递它们。在一些情况下，比起用Lambda表达式，它们似乎更易读，感觉也更自然。
方法引用主要有三类。
1、指向静态方法的方法引用（例如Integer的parseInt方法，写作Integer::parseInt）。
2、指向任意类型实例方法的方法引用（例如String的length方法，写作String::length）。
3、指向现有对象的实例方法的方法引用（假设你有一个局部变量client用于存放YouZanClient类型的对象，它支持实例方法getClient，那么你就可以写client::getClient。
//先前
inventory.sort((Apple a1, Apple a2)
-> a1.getWeight().compareTo(a2.getWeight()));
//使用方法引用之后
//֖java.util.Comparator.comparing
inventory.sort(comparing(Apple::getWeight));
学习到现在，你能够自己写Lambda表达式了吗？⛽️
下一节或介绍复合Lambda表达式的有用方法哦！
转载：https://blog.csdn.net/lp15203883326/article/details/101166048