Lambda表达式
引入函数式编程风格：
在以前调用Java方法的时候，实参必须是一个基本数据类型的值或者是一个对象，现在可以给一些引用数据类型的形参，传一段代码而不是一个对象（这段代码是一个函数的主体方法）。
Lambda表达式的好处：
可以极大地减少代码冗余，同时可读性也好过冗长的匿名内部类
并不是所有的引用数据类型都可以使用Lambda表达式，只有少部分可以使用
SAM（函数式接口）类型的形参，变量才可以赋值为Lambda表达式
函数式接口：只有一个抽象方法的接口，这个接口可以有默认方法和静态方法成员等
结论：
1.只有函数式接口才能使用Lambda表达式
2.Lambda作用就是简化代码，使代码更整洁
例如：
public class Teacher {
private int age;
private String name;
public Teacher() {}
public Teacher(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Teacher{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}TreeSetadd的对象必须实现Comparator接口，否则就在调用时写入，或者用Lambda写入。
public class TestLambda {
@Test
public void test4(){
// TreeSet 中添加Teacher对象 Lambda表达式
TreeSet<Teacher> teachers = new TreeSet<>((teacher1,teacher2) -> teacher1.getAge() - teacher2.getAge());
teachers.add(new Teacher());
teachers.add(new Teacher(18,"Y"));
for (Teacher teacher : teachers
) {
System.out.println(teacher);
}
}
@Test
public void test3(){
// TreeSet 中添加Teacher对象
TreeSet<Teacher> teachers = new TreeSet<>(new Comparator<Teacher>() { // 未在Teacher中实现Comparator接口 在这里传
@Override
public int compare(Teacher teacher, Teacher t1) {
return t1.getAge() - teacher.getAge();
}
});
teachers.add(new Teacher());
teachers.add(new Teacher(18,"Y"));
for (Teacher teacher : teachers
) {
System.out.println(teacher);
}
}
@Test
public void test2(){
// Lambda创建线程
new Thread(() -> System.out.println("Lambda")).start();
}
@Test
public void test1(){
// 匿名内部类创建线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
}
}函数式接口：
SAM （Single Abstract Method），即该接口中有且仅有一个抽象方法需要实现（当然该方法可以包含其他非抽象方法）
学习的有且仅有一个抽象方法的接口：
- java.lang.Runnable: public void run()
- java.lang.Comparable :public int compareTo(T t)
- java.util.Comparator :public int compare(T t1, T t2)
- java.lang.Iterable:public Iterator iterator()
- java.lang.reflect.InvocationHandler:public Object invoke(Object proxy,Method method,Object[] args)
- java.io.FileFilter:public boolean accept(File pathname)
如上接口中，都符合有且仅有一个抽象方法，但在JDK1.8之后建议在所有函数式接口添加注解@FunctionalInterface
而没有添加的说明在以后的JDK版本更新时，可能会添加抽象方法，现在用Lambda表达式没问题，但JDK更新之后不确定
Runnable、Comparator、FileFilter都是确定的函数式接口
public class TestFunctionalInterface {
@Test
public void test2(){
File file = new File("D:\\IOtest\\123456\\12\\5\\123"); //是一个文件夹
// 遍历文件夹中以.docx结尾的文件
File[] files = file.listFiles((file1) -> file1.getName().endsWith(".docx"));//Lambda表达式：（传参） -> 结果
for (File f : files
) {
System.out.println(f);
}
}
@Test
public void test(){
File file = new File("D:\\IOtest\\123456\\12\\5\\123"); //是一个文件夹
// 遍历文件夹中以.docx结尾的文件
File[] files = file.listFiles(new FileFilter() {
@Override
public boolean accept(File file) {
if (file.getName().endsWith(".docx"))
return true;
return false;
}
});
for (File f : files
) {
System.out.println(f);
}
}
}
@FunctionalInterface
interface MyInterface{
void test();
}JDK1.8新增了很多包，其中一个包：java.lang.funtion
提供了函数式接口
这些接口主要可以分为四大类：
- 1.消费型接口（Consumer）：
它的抽象方法有参无返回值 - 2.供给型接口（Supplier）：
无参有返回值 - 3.判断型接口（Predicate）：
无论什么参数，输出的都是true或者false - 4.功能型接口（Function）：
有参有返回值
消费型接口：
- 有参无返回值
- 最基本的代表：Consumer : void accept(T t)
- 例如：集合java.util.Collection系列在JDK1.8之后就增加了这样的方法：
- default void forEach(Consumer<? super T> action)
public class TestConsumer {
@Test
public void test(){
// 创建一个集合
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("你好");
arrayList.add("世界");
arrayList.add("java");
arrayList.add("Lambda");
// 遍历集合：
// for (String s : arrayList
// ) {
// System.out.println(s);
// }
// 用forEach方法遍历 Lambda表达式
arrayList.forEach((string) -> System.out.println(string));
}
}供给型接口：
无参有返回值
最基本的代表：
Supplier :T get()
举例：
StreamAPI：
- Stream是一个数据流， java.util.stream包的Stream类型
static <T> Stream<T> generate(Supplier<T> s)public class TestSupplier {
@Test
public void test(){
// generate产生
// Math.random():随机数
Stream<Double> stream = Stream.generate(() -> Math.random());
// 遍历 Lambda表达式
stream.forEach((d) -> System.out.println(d));
}
}判断型接口
抽象方法：boolean test(参数)
最基本代表：
Predicate boolean test(T t)
举例：
- java.util.Collection
default boolean removeIf(Predicate<? super E> filter)
public class TestPredicate {
@Test
public void test(){
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 1; i <=10; i++) {
arrayList.add(i);
}
// 移除三和三的倍数，并遍历
// arrayList.remove(3); 太麻烦
// arrayList.remove(6);
// arrayList.remove(9);
// 方法二：迭代器
// Iterator<Integer> iterator = arrayList.iterator();
// while (iterator.hasNext()){
// Integer num = iterator.next();
// if (num % 3 == 0){
// iterator.remove();
// }
// }
// for (Integer i : arrayList
// ) {
// System.out.println(i);
// }
// 方法三
arrayList.removeIf((integer) -> integer%3 == 0);// 如果是三的倍数，即remove
for (Integer i : arrayList
) {
System.out.println(i);
}
}
}lambda表达式语法：
Lambda表达式就是给函数式接口的形参或变量赋值用的，为了给这个函数式接口的抽象方法传递代码用
- 语法格式：
(形参列表) -> {Lambda体}
(形参列表)就是函数式接口的抽象方法的形参列表
{lambda体}就是函数式接口的抽象方法的方法体 - 说明：
1.当形参列表是空参时，那么（）不能省略
2.当形参列表是非空参时，并且数据类型是确定的或者可以推断的，那么形参的数据类型可以省略
3.当形参列表是非空参时，并且只有一个形参，且类型也省略了，那么此时（）也可以省略，如果类型没有省略，（）也不能省略
4.如果{lambda}不只有一个语句，那么{}不能省略，并且每一句都要加;
5.如果{lambda}只有一个语句，那么{}和;都可以省略（同时省略）
6.如果该函数式接口的抽象方法的返回值类型不是void，那么{lambda体}里要有return 返回值语句; 当{lambda}中只有一个{return 返回值;}时，{}、;、return都同时省略
public class TestLambdaGrammar {
@Test
public void test(){
// 创建一个集合
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("你好");
arrayList.add("世界");
arrayList.add("java");
arrayList.add("Lambda");
arrayList.forEach(new Consumer<String>() {// 匿名内部类方式
// 用匿名内部类方式给Consumer接口的形参赋值
@Override
public void accept(String s) {
System.out.println(s);
}
});
// 用forEach方法遍历 Lambda表达式 完整版
arrayList.forEach((String string) -> {System.out.println(string);});
}
}Lambda表达式练习
1.使用forEach(Consumer c)方法便利Collection系列集合
创建一个ArrayList集合，保存Teacher对象，用上述方法遍历
public class TestExer1 {
public static void main(String[] args) {
ArrayList<Teacher> teachers = new ArrayList<>();
teachers.add(new Teacher(24,"Sam"));
teachers.add(new Teacher(25,"Ann"));
teachers.add(new Teacher(21,"Blue"));
teachers.add(new Teacher(24,"DiDi"));
teachers.add(new Teacher(26,"YuWei"));
teachers.forEach(teacher -> System.out.println(teacher));
}
}2.使用removeIf(Predicate p) 删除元素
创建一个ArrayList集合，储存Teacher对象，删除年龄大于25的教师
public class TestExer2 {
public static void main(String[] args) {
ArrayList<Teacher> teachers = new ArrayList<>();
teachers.add(new Teacher(24,"Sam"));
teachers.add(new Teacher(25,"Ann"));
teachers.add(new Teacher(21,"Blue"));
teachers.add(new Teacher(24,"DiDi"));
teachers.add(new Teacher(26,"YuWei"));
// 删除年龄大于25的教师
teachers.removeIf(teacher -> teacher.getAge()>25);
// lambda遍历
teachers.forEach(teacher -> System.out.println(teacher));
}
}3.（1）教师类实现Comparable接口 按年龄排序并遍历
（2）按姓名首字母排序
public class TestExer3 {
@Test
public void test1(){
TreeSet<Teacher> teachers = new TreeSet<>();
teachers.add(new Teacher(24,"Sam"));
teachers.add(new Teacher(25,"Ann"));
teachers.add(new Teacher(21,"Blue"));
teachers.add(new Teacher(24,"DiDi"));
teachers.add(new Teacher(26,"YuWei"));
// lambda遍历
teachers.forEach(teacher -> System.out.println(teacher));
}
@Test
public void test2(){
// 按名字首字母排列
TreeSet<Teacher> teachers = new TreeSet<>((t1,t2) -> t1.getName().compareToIgnoreCase(t2.getName()));
teachers.add(new Teacher(24,"Sam"));
teachers.add(new Teacher(25,"Ann"));
teachers.add(new Teacher(21,"Blue"));
teachers.add(new Teacher(24,"DiDi"));
teachers.add(new Teacher(26,"YuWei"));
// lambda遍历
teachers.forEach(teacher -> System.out.println(teacher));
}
}4.创建一个HashMap，key是你的名字，value是你对象的名字
使用Map的default void forEach（）方法遍历
import java.util.HashMap;
public class TestExer4 {
public static void main(String[] args) {
HashMap<String,String> names = new HashMap<>();
names.put("YYX","DLQ");
names.forEach((yyx,dlq) -> System.out.println("我是" + yyx + "我的女朋友是" + dlq));
}
}感谢段段
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
