Java中Lambda表达式⽤法介绍
Lambda
lambda是⼀个匿名函数，我们可以把lambda表达式理解为是⼀段可以传递的代码。
lambda简明的地将代码或⽅法作为参数传递进去执⾏。
“函数式编程”其核⼼是把函数作为值。
函数式接⼝：只有⼀个抽象⽅法的接⼝称之为函数式接⼝。函数式接⼝可以使⽤@FunctionalInterface进⾏注解。lambda表达式拆分为两部分
左侧：lambda 表达式的参数列表
右侧：lambda 表达式中所需要执⾏的功能，即lambda体
语法格式⼀：⽆参数，⽆返回值
@Test
public void test(){
// () -> System.out.println("Hello");
Runnable a = new Runnable(){
@Override
public void run(){
System.out.println("Hello")
}
};
//等同于
Runnable a1 = () -> System.out.println("Hello");
a1.run();
}
语法格式⼆：有⼀个参数，⽆返回值（若只有⼀个参数⼩括号可以省略不写）
@Test
public void test(){
//Consumer被注解@FunctionalInterface的接⼝（函数式接⼝）唯⼀抽象⽅法 void accept(T t);
//左侧参数 -> 右侧执⾏体
Consumer<String> con = (x) -> System.out.println(x);
// x -> System.out.println(x);
con.accept("hahah");
}
语法格式三：有两个以上的参数，并且lambda体中有多条语句 (若lambda体中只有⼀条语句，return 和⼤括号都可以省略不写)
@Test
public void test(){
//Comparator被注解@FunctionalInterface的接⼝举例抽象⽅法 int compare(T o1,T o2);
Comparator<Integer> com = (x,y) -> {
System.out.println("hhaha0");
return (x < y) ? -1 : ((x == y) ? 0 : 1);
};
compare(1,2);
}
注意：lambda表达式的参数类型可以省略不写，因为jvm编译器可以从上下⽂推断出数据类型。即“类型推断”如果要在参数⾥⾯写数据类型，都要写上。
实例
实例1：
class Employee {
private String name;
private int age;
private double salary;
//省略 get and set and constructor
}
interface MyPredicate<T> {
boolean test(T t);
}
public class Test{
static List<Employee> list = Arrays.asList(
new Employee("张三",10,1),
new Employee("⾥斯",20,1),
new Employee("王五",16,1),
new Employee("⼆三",30,1)
);
public static List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
List<Employee> emps = new ArrayList<>();
for (Employee employee : list) {
st(employee)){
emps.add(employee);
}
}
return emps;
}
@org.junit.Test
public void test1(){
//需要使⽤⾃定义的⽅法
List<Employee> list2 = filterEmployee(list,(e) -> e.getAge() >= 15);
list2.stream().map(Employee::getName).forEach(System.out::println);
}
@org.junit.Test
public void test2(){
/
/可以使⽤stream进⾏list集合的过滤不使⽤⾃定义接⼝
List<Employee> list2 = list.stream().filter((e) -> e.getAge() >= 15).List());
list2.stream().map(Employee::getName).forEach(System.out::println);
}
}
实例2：
创建⼀个MyFun接⼝使⽤@FunctionalInterface注解，并创建⼀个抽象⽅法Integer getValue(Integer num)；在Test类对变量进⾏某种操作。
@FunctionalInterface
interface MyFun{
Integer getValue(Integer num);
}
public class Test{
@org.junit.Test
public void Test(){
java arraylist用法operation(100,num -> ++num);
}
/**
* param1 num : 传⼊的整形数
* param2 mf : 实现某种⽅式对整形数进⾏操作。
**/
public Integer operation(Integer num,MyFun mf){
Value(num);
}
}
class Employee {
private String name;
private int age;
private double salary;
@Override
public String toString() {
return "["+this.name+","+Age()+","+Salary()+"]";
}
//省略 getter and setter  and constructor
}
public class Test {
List<Employee> list = Arrays.asList(
new com.st1.Employee("张三",10,1),
new com.st1.Employee("⾥斯",20,1),
new com.st1.Employee("王五",16,1),
new Employee("⼆三",30,1)
);
@org.junit.Test
public void test(){
Collections.sort(list,(e1,e2) -> {
Age() == e2.getAge()){
Name()Name());
}else{
//⽐较年龄⼤⼩
return Age(),e2.getAge());
}
});
for (Employee e: list) {
System.out.println(e);
}
}
}
四⼤核⼼函数式接⼝
Consumer<T> : 消费性接⼝ void accept(T t);
Supplier<T> : 共给性接⼝ T get();
Function<T,R> : 函数性接⼝ T代表参数，R代表返回值 R apply(T t);
Predicate<T> ：断⾔性接⼝ boolean test(T t);
class Test{
@org.junit.Test
publilc void test(){
happy(10000,(money)->System.out.println("happy消费"+money+"元"));
}
public void happy(double money,Consumer<double> con){
con.accept(money);
}
}
lambda⽅法引⽤
⽅法引⽤：若lambda体中的内同有⽅法已经实现了，我们可以使⽤“⽅法引⽤”
（可以理解为⽅法引⽤时lambda的另⼀种表现形式）
主要有三种语法格式：
对象:：实例⽅法名
类:：静态⽅法名
类:：实例⽅法名
class Test{
//对象:：实例⽅法名
@org.junit.Test
public void test(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("haha");
Consumer<String> con2 = System.out::println;
con2.accept("haha");
}
//类:：静态⽅法名
@org.junit.Test
public void test2(){
Comparator<Integer> com = (x,y) -> Integerpare(x,y);
Comparator<Integer> com2 = Integer::compare;
compare(1,2);
com2pare(1,2);
}
//类:：实例⽅法名
@org.junit.Test(){
BiPredicate<String,String> bp = (x,y) -> x.equals(y);
BiPredicate<String,String> bp2 = String::equals;
}
}
lambda构造器引⽤
格式：
CalssName::new
class Test{
@org.junit.Test
public void test(){
Supplier<String> sup = () -> new String();
//这⾥的构造器引⽤取决于接⼝⽅法的参数的个数。此处函数式接⼝ T get(); 为⽆参抽象⽅法所以String在实例化时也是实例化⽆参的构造⽅法其他类也适⽤
Supplier<String> sup2 = String::new;
String str = ();
}
}
到此这篇关于Java中Lambda表达式⽤法介绍的⽂章就介绍到这了。希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。