#Lambda表达式
Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中)
#lambda表达式本质上就是一个匿名方法。比如下面的例子:
public int add(int x, int y) {
return x + y;
}
转成Lambda表达式后是这个样子:
(int x, int y) -> x + y;
参数类型也可以省略,Java编译器会根据上下文推断出来:
(x, y) -> x + y; //返回两数之和
或者
(x, y) -> { return x + y; } //显式指明返回值
#java 8 in Action这本书里面的描述:
A lambda expression can be understood as a concise representation of an anonymous function
that can be passed around: it doesn’t have a name, but it has a list of parameters, a body, a
return type, and also possibly a list of exceptions that can be thrown. That’s one big definition;
#格式:
(x, y) -> x + y;
-----------------
(x,y):参数列表
x+y : body
#Lambda表达式用法实例:
package LambdaUse;
/**
* @author zhangwenlong
* @date 2019/8/25 15:17
*/
public class LambdaUse {
public static void main(String[] args) {
//匿名类实现
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello world");
}
};
//Lambda方式实现
Runnable r2 = ()-> System.out.println("Hello world");
process(r1);
process(r2);
process(()-> System.out.println("Hello world"));
}
private static void process(Runnable r){
r.run();
}
}
输出的结果:
Hello world
Hello world
Hello world
FunctionalInterface注解修饰的函数
#predicate的用法
package LambdaUse;
import java.applet.Applet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.LongPredicate;
import java.util.function.Predicate;
/**
* @author zhangwenlong
* @date 2019/8/25 15:30
*/
public class PredicateTest {
//通过名字(Predicate实现)
private static List<Apple> filterApple(List<Apple> list, Predicate<Apple> predicate){
List<Apple> appleList = new ArrayList<>();
for(Apple apple : list){
if(predicate.test(apple)){
appleList.add(apple);
}
}
return appleList;
}
//通过重量(LongPredicate实现)
private static List<Apple> filterWeight(List<Apple> list, LongPredicate predicate){
List<Apple> appleList = new ArrayList<>();
for(Apple apple : list){
if(predicate.test(apple.getWeight())){
appleList.add(apple);
}
}
return appleList;
}
public static void main(String[] args) {
List<Apple> list = Arrays.asList(new Apple("苹果",120),new Apple("香蕉",110));
List<Apple> applelist = filterApple(list,apple -> apple.getName().equals("苹果"));
System.out.println(applelist);
List<Apple> appleList = filterWeight(list, (x) -> x > 110);
System.out.println(appleList);
}
}
执行结果:
[Apple{name='苹果', weight=120}]
[Apple{name='苹果', weight=120}]
#Lambda表达式的方法推导
package LambdaUse;
import java.util.function.Consumer;
/**
* @author zhangwenlong
* @date 2019/8/25 16:02
*/
public class MethodReference {
private static <T> void useConsumer(Consumer<T> consumer,T t){
consumer.accept(t);
}
public static void main(String[] args) {
//定义一个匿名类
Consumer<String> stringConsumer = (s) -> System.out.println(s);
useConsumer(stringConsumer,"Hello World");
//lambda
useConsumer((s) -> System.out.println(s),"ni hao");
//Lambda的方法推导
useConsumer(System.out::println,"da jia hao");
}
}
执行结果:
Hello World
ni hao
da jia hao
参数推导其他例子:
package LambdaUse;
import java.net.Inet4Address;
import java.util.function.BiFunction;
import java.util.function.Function;
/**
* @author zhangwenlong
* @date 2019/8/25 16:53
*/
public class paramterMethod {
public static void main(String[] args) {
//情况1:A method reference to a static method (for example, the method parseInt of Integer, written Integer::parseInt)
//静态方法
//常用的使用
Integer value = Integer.parseInt("123");
System.out.println(value);
//使用方法推导
Function<String,Integer> stringIntegerFunction = Integer::parseInt;
Integer apply = stringIntegerFunction.apply("123");
System.out.println(apply);
//情况2:A method reference to an instance method of an arbitrary type (for example, the method length of a String, written String::length)
//对象的方法
String ss = "helloWorld";
System.out.println(ss.charAt(3));
//推导方法
BiFunction<String,Integer,Character> stringIntegerCharacterBiFunction = String::charAt;
System.out.println(stringIntegerCharacterBiFunction.apply(ss,3));
//情况3:构造函数方法推导
//常用方式
Apple apple = new Apple("苹果",120);
System.out.println(apple);
//推导方式
BiFunction<String,Integer,Apple> appleBiFunction = Apple::new;
System.out.println(appleBiFunction.apply("苹果",120));
}
}
执行结果:
123
123
l
l
Apple{name='苹果', weight=120}
Apple{name='苹果', weight=120}
具体的详细解释可以参考:
#Stream(流以及一些常用的方法)
特点:并行处理
例子:
package StreamUse;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author zhangwenlong
* @date 2019/8/25 17:20
*/
public class StreamTest {
public static void main(String[] args) {
List<Apple> appleList = Arrays.asList(
new Apple("苹果",110),
new Apple("桃子",120),
new Apple("荔枝",130),
new Apple("香蕉",140),
new Apple("火龙果",150),
new Apple("芒果",160)
);
System.out.println(getNamesByCollection(appleList));
System.out.println(getNamesByStream(appleList));
}
//collection实现查询重量小于140的水果的名称
private static List<String> getNamesByCollection(List<Apple> appleList){
List<Apple> apples = new ArrayList<>();
//查询重量小于140的水果
for(Apple apple : appleList){
if(apple.getWeight() < 140){
apples.add(apple);
}
}
//排序
Collections.sort(apples,(a,b)->Integer.compare(a.getWeight(),b.getWeight()));
List<String> appleNamesList = new ArrayList<>();
for(Apple apple : apples){
appleNamesList.add(apple.getName());
}
return appleNamesList;
}
//stream实现查询重量小于140的水果的名称
private static List<String> getNamesByStream(List<Apple> appleList){
return appleList.stream().filter(d ->d.getWeight() < 140)
.sorted(Comparator.comparing(Apple::getWeight))
.map(Apple::getName)
.collect(Collectors.toList());
}
}