Java中Lambda表达式的使用详解

理解函数式接口以及 Lambda表达式的发展过程

任何接口，只包含唯一一个抽象方法，就是函数式接口

/**
* lambdab表达式的发展
*/
public class TestLambda1 {
   //3.静态内部类
   static class Like2 implements ILike{
       @Override
       public void lambda() {
           System.out.println("i like lambda2");
       }
   }

public static void main(String[] args) {
       ILike like=new Like();
       like.lambda();

like=new Like2();
       like.lambda();

//4.局部内部类
      class Like3 implements ILike{
           @Override
           public void lambda() {
               System.out.println("i like lambda3");
           }
       }
       like=new Like3();
       like.lambda();

//5.匿名内部类
       like=new ILike() {
           @Override
           public void lambda() {
               System.out.println("i like lambda4");
           }
       };
       like.lambda();

//6.用lambda简化
       like=()->{
           System.out.println("i like lambda5");
       };
       like.lambda();
   }
}

//1.定义一个函数式接口
interface ILike{
   void lambda();
}

//2.实现类
class Like implements ILike{

@Override
   public void lambda() {
       System.out.println("i like lambda");
   }
}

Lambda表达式及语法

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

// 1. 不需要参数,返回值为 5  
() -> 5  

// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  

// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  

// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

也就是说，不需要事先声明参数的类型，圆括号可以没有，大括号可以没有，返回值可以没有

一起来看看具体的使用

public class java8_Lambda_Test {
   public static final void main(String[] args) {

Operator addOper = (a, b) -> a + b;
       Operator reduceOper = (a, b) -> a - b;
       Operator multiplyOper = (a, b) -> a * b;
       Operator DivideOper = (a, b) -> a / b;

java8_Lambda_Test test = new java8_Lambda_Test();
       System.out.println(test.getResult(3, 3, addOper));//6
       System.out.println(test.getResult(3, 3, reduceOper));//0
       System.out.println(test.getResult(3, 3, multiplyOper));//9
       System.out.println(test.getResult(3, 3, DivideOper));//1
   }

public int getResult(int a, int b, Operator operator) {
       return operator.convert(a, b);
   }

public interface Operator {
       int convert(int a, int b);
       default int get(int a) {
           return a;
       }
   }
}

你需要注意什么

1.lambda 表达式只能引用标记了 final 的外层局部变量
2.可以直接在 lambda 表达式中访问外层的局部变量

Lambda的实际运用

1.对集合排序

问题描述：在一个存放了Student对象的list中，按年龄进行排序，输出排序后的list

Student类

public class Student implements Comparable<Student>{
   private String name;
   private int age;

public String getName() {
       return name;
   }

public void setName(String name) {
       this.name = name;
   }

public int getAge() {
       return age;
   }

public void setAge(int age) {
       this.age = age;
   }

@Override
   public int compareTo(Student student2) {
      int result =this.age - student2.age;
      return result;
   }
}

       List<Student> list=new ArrayList<>();
       Student s1=new Student();
       s1.setName("张三");
       s1.setAge(28);
       list.add(s1);
       Student s=new Student();
       s.setName("李四");
       s.setAge(22);
       list.add(s);
       sortUsingJava8(list);

list.forEach((student) -> System.out.println(student.getName() + ":"+student.getAge()));

// 使用 java 8 排序
   static void sortUsingJava8(List<Student> list){
       Collections.sort(list, (student1, student2) -> student1.compareTo(student2));
   }

来康康使用Java7进行排序是这样的：

   // 使用 java 7 排序
   private void sortUsingJava7(List<String> list){
       Collections.sort(list, new Comparator<String>() {
          @Override
          public int compare(String s1, String s2) {
               return s1.compareTo(s2);
           }
       });
   }

2.遍历集合

//先准备一个集合
       List<Student> list=new ArrayList<>();
       Student s1=new Student();
       s1.setName("张三");
       s1.setAge(28);
       list.add(s1);
       Student s=new Student();
       s.setName("李四");
       s.setAge(22);
       list.add(s);
//使用 lambda 表达式以及函数操作(functional operation)
 list.forEach((student) -> System.out.println(student.getName() + ":"+student.getAge()));

3.遍历集合（带条件）

//带条件 打印年龄大于等于20的学生的姓名
       list.forEach((student)->{
           if (student.getAge()>=20)
               System.out.println(student.getName());
               });

4.代替 Runnable，开启一个线程

Runnable r = new Runnable() {
   @Override
   public void run() {
       //to do something
   }
};
Thread t = new Thread(r);
t.start();

现在这样写：

Runnable r = () -> {
   //to do something
};
Thread t = new Thread(r);
t.start();

你还可以这样写：

Thread t = new Thread(() -> {
   //to do something
   // such as for
   for(int i = 0; i < 100; i++){
       System.out.println(i);
          }
});
t.start;

来源：https://blog.csdn.net/sxh06/article/details/120126810