我使用 Lambda 表达式将上百行的代码精简到几行，掌握这十个搜索技巧让你的工作效率至上提高十倍-CSDN博客

本文链接：https://blog.csdn.net/erthre/article/details/137197460

}

public class Main {

public static void main(String[] args) {

// 方式一直接编写实现类

Human human = new Man();

human.speak();

}

如果我们不想编写一个单独的实现类（Man），则可以用匿名内部类。如方式二：

public class Main {

public static void main(String[] args) {

// 方式一直接编写实现类

Human human = new Man();

human.speak();

// 方式二匿名内部类

Human human1 = new Human() {

@Override

public void speak() {

System.out.println(“I am woman!”);

}

};

human1.speak();

}

但方式二中，有用的就只有System.out.println("I am woman!");这一行，所以有了Lambda表达式，可以这样写，如方式三：

public class Main {

public static void main(String[] args) {

// 方式一直接编写实现类

Human human = new Man();

human.speak();

// 方式二匿名内部类

Human human1 = new Human() {

@Override

public void speak() {

System.out.println(“I am woman!”);

}

};

human1.speak();

// 方式三 Lambda表达式

Human human2 = () -> System.out.println(“I am woman!”);

human2.speak();

}

2.2 案例二

再假如我们要对一个Student类的数组按指定条件进行过滤，如下：

public class Student {

private String name;

private int age;

private double score;

}

public class Main {

public static void main(String[] args) {

List students = Arrays.asList(new Student(“张三”, 18, 89.5),

new Student(“李四”, 20, 60), new Student(“王五”, 19, 100), new Student(“赵六”, 22, 89));

// 过滤出年龄大于等于20的学生

List stus1 = filterStudentByAge(students);

System.out.println(stus1);

// 过滤出成绩大于80的学生

List stus2 = filterStudentByScore(students);

System.out.println(stus2);

}

// 过滤出年龄大于等于20的学生

private static List filterStudentByAge(List students) {

List stus = new ArrayList<>();

for (Student stu : students) {

if (stu.getAge() >= 20) {

stus.add(stu);

}

return stus;

}

// 过滤出成绩大于80的学生

private static List filterStudentByScore(List students) {

List stus = new ArrayList<>();

for (Student stu : students) {

if (stu.getScore() > 80) {

stus.add(stu);

}

return stus;

}

按上面的方式，如果要按另外一个条件过滤呢，又要写一个方法。那可以用策略模式处理，编写一个抽象策略接口，然后编写多个不同策略类实现它。

// 策略接口

public interface MyPredicate {

boolean test(T t);

}

// 过滤出年龄大于等于20的学生

public class filterStudentByAge implements MyPredicate {

@Override

public boolean test(Student t) {

return t.getAge() >= 20;

}

// 过滤出成绩大于80的学生

public class filterStudentByScore implements MyPredicate {

@Override

public boolean test(Student t) {

return t.getScore() > 80;

}

public class Main {

public static void main(String[] args) {

List students = Arrays.asList(new Student(“张三”, 18, 89.5),

new Student(“李四”, 20, 60), new Student(“王五”, 19, 100), new Student(“赵六”, 22, 89));

// 过滤出年龄大于等于20的学生

List stus1 = filterStudent(students, new FilterStudentByAge());

System.out.println(stus1);

// 过滤出成绩大于80的学生

List stus2 = filterStudent(students, new FilterStudentByScore());

System.out.println(stus2);

}

// 按myPredicate策略过滤出满足条件的学生

private static List filterStudent(List students,

MyPredicate myPredicate) {

List stus = new ArrayList<>();

for (Student stu : students) {

if (myPredicate.test(stu)) {

stus.add(stu);

}

return stus;

}

但是以上方式，每增加一个过滤条件，就要编写一个策略类，太麻烦。所以我们就用匿名内部类方式。

// 匿名内部类形式过滤出年龄大于等于18的学生

List stus3 = filterStudent(students, new MyPredicate() {

@Override

public boolean test(Student t) {

return t.getAge() > 18;

}

});

System.out.println(stus3);

但我们会觉得匿名内部类还是太麻烦，无用代码太多，有用的代码其实就只有return t.getAge() > 18;，于是 Lambda 表达式发挥的作用就来了：

// Lambda形式过滤出年龄大于等于18的学生

List stus4 = filterStudent(students, t -> t.getAge() > 18);

System.out.println(stus4);

这时还是有人会问，那我们定义的接口MyPredicate和方法filterStudent()，好像没什么作用呀。然而官方已经想到这一点，它内置了一些通用接口，我们可以使用它。例如断言的接口 Predicate，那我们就用如下方式，完全不用写接口MyPredicate和方法filterStudent()，如下：

// 按myPredicate策略过滤出满足条件的学生

private static List filterStudent(List students,

Predicate predicate) {

List stus = new ArrayList<>();

for (Student stu : students) {

if (predicate.test(stu)) {

stus.add(stu);

}

return stus;

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！