必须是函数式接口才可以使用Lambda
函数式接口:内部只有一个方法。
lambda表达式,其实本质来讲,就是⼀个匿名函数。因此在写lambda表达式的时候,不需要关心方法名是什么。
实际上,我们在写lambda表达式的时候,也不需要关心返回值类型。
我们在写lambda表达式的时候,只需要关注两部分内容即可:参数列表和方法体
lambda表达式的基础语法:
(参数1,参数2,…) -> {
方法体
};
参数部分:方法的参数列表,要求和实现的接口中的方法参数部分⼀致,包括参数的数量和类型。
方法体部分 : 方法的实现部分,如果接口中定义的方法有返回值,则在实现的时候,注意返回值的返回。
-> : 分隔参数部分和方法体部分。
用Lambda表达式实现接口
public class Test04 {
public static void main(String[] args) {
//使用lambda表达式实现接口
Test test = () -> {
System.out.println("test");
};
test.test();
}
}
interface Test{
public void test();
}
2.格式说明:
- 小括内的语法与传统方法参数列表一致,没有参数就留空,有多个参数就用逗号分隔
- 【->】 是新引入的语法格式,代表指向动作
- 大括号内的语法与传统方法体要求一致
市场非常AV
package atest;
import java.util.Arrays;
import java.util.Comparator;
public class pratise2 {
//内部类
// static class StudentCompare implements Comparator<Student>{
// public int compare(Student o1, Student o2) {
//
// return o1.name.length() - o2.name.length();//正序
//
// }
// }
public static void main(String[] args) {
/* class StudentCompare implements Comparator<Student>{
public int compare(Student o1, Student o2) {
return o1.name.length() - o2.name.length();//正序
}
}*/
Student[] s = new Student[4];
s[0] = new Student();
s[0].age = 17;
s[0].name = "lucy";
s[1] = new Student();
s[1].age = 18;
s[1].name = "tom";
s[2] = new Student();
s[2].age = 19;
s[2].name = "danny";
s[3] = new Student();
s[3].age = 20;
s[3].name = "jan";
Arrays.sort(s);
for(Student student :s) {
System.out.println(student.age);
}
/* Arrays.sort(s,new StudentCompare());
for(Student student :s) {
System.out.println(student.name);
}*/
//函数
/* Arrays.sort(s,new Comparator<Student>() {
public int compare(Student o1, Student o2) {
return o1.name.length() - o2.name.length();//正序
}
});*/
Arrays.sort(s,(o1,o2)->{return o1.name.length() - o2.name.length();});
for(Student student :s) {
System.out.println(student.name);
}
}
}
class Student implements Comparable<Student>{
String name;
int age;
@Override
public int compareTo(Student o) {//0相等 正数--正序 负数--倒序
//return o.age - age;
return age - o.age;
}
}
//class StudentCompare implements Comparator<Student>{
// public int compare(Student o1, Student o2) {
//
// return o1.name.length() - o2.name.length();//正序
//
// }
//}
Lambada表达式
统调用借口中的方法就可以调用{
}中所有的东西
public class LambadaTest {
/* (2)静态内部类
static class Like implements ILike{
@Override
public void lambda() {
System.out.println("我是Lambda");
}
}*/
public static void main(String[] args) {
/*(3)局部内部类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("我是Lambda");
}
}*/
/* Like bh=new Like();
ILike il=new Like();*/
//(4)匿名内部类
/* like=new ILike(){
@Override
public void lambda() {
}
};*/
//Lambada 表达式
ILike like=()->{
System.out.println("Lambada表达式");
};
like.lambda();
/*il.lambda();*/
}
}
interface ILike{
void lambda();
}
/*
(1)
class Like implements ILike{
@Oerride
public void lambda() {
System.out.println("我是Lambda");
}
}*/
简单一点来说就是不用建类 直接new 接口
ILike like=new ILike() {
@Override
public void lambda(int a) {
}
};
然后自new开始删除 直到方法名 加上->即可
ILike like=(int a)-> {
System.out.println("zhilishi"+a);
};
那么我们是否可以继续简化呢
//仅有一行时才可以简化 有多行只能用花括号
like=a -> System.out.println(a);