JDK1.8新特性---------lambda

1. Lambda表达式

1.1 概念

• Lambda表达式: 特殊的匿名内部类，语法更加简洁 .是JDK1.8中的新特性.
• Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递.

1.2 需求

1、开启一个线程。并执行一个Runnable类型的任务。

public class Test01 {
    public static void main(String[] args) {
        //匿名内部类
        Runnable tast1=new Runnable() {
            public void run() {
                System.out.println("这是使用匿名内部类"+Thread.currentThread().getName());
            }
        };
        new Thread(tast1).start();

        System.out.println("主线程的内容:"+Thread.currentThread().getName());
    }
}

1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
2. 为了指定run方法体，不得不需要Runnable的实现类
3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
5. 而实际上，我们只在乎方法体中的代码.不会在意方法名.

1.3 lambda的语法

lambda表达式它由三部分组成

(数据类型 变量名,数据类型 变量名)->{方法体}

格式说明：

• (参数类型 参数名称):参数列表
• {代码体;} :方法体
• -> : 箭头，分割参数列表和方法体

1. 4Lambda练习

练习无参无返回值的Lambda

public class Test02 {
    public static void goShow(UserService userService){
         userService.show();
    }

    public static void main(String[] args) {
        //1.自己创建一个UserService接口的实现类。并创建该类的对象。
        UserService userService=new UserServiceImpl();
        goShow(userService);
        //2.使用匿名内部类
        UserService userService1=new UserService() {
            @Override
            public void show() {
                System.out.println("这是UserService的匿名实现类");
            }
        };
        goShow(userService1);

        //3.使用lambda表达式
        UserService userService2=()->{
            System.out.println("这是lambda表达式");
        };
        goShow(userService2);
    }
}
interface UserService{
     public void show();
}
class UserServiceImpl implements UserService{

    @Override
    public void show() {
        System.out.println("这是UserService实现方法");
    }
}

1.5 Lambda练习2

完成一个有参且有返回值得Lambda表达式案例.

创建一个People对象

@Data
@NoArgsConstructor
@AllArgsConstructor
class People{
     private String name;
     private int age;
}

测试:

public class Test03 {
     public static void main(String[] args) {
          List<People> list=new ArrayList<People>();
        students.add(new Student("张三",34));
        students.add(new Student("李四",45));
        students.add(new Student("王五",25));
        students.add(new Student("糖糖",35));

          //按照年龄进行排序。第二个参数需要传递排序规则
//          Comparator<People> comparator=new Comparator<People>() {
//               public int compare(People o1, People o2) {
//                    return o1.getAge()-o2.getAge();
//               }
//          };
//          Collections.sort(list,comparator);
//          System.out.println(list);

          System.out.println("=============================================");
          Comparator<People> comparator1=(People o1,People o2)->{return o2.getAge()-o1.getAge();};
          Collections.sort(list,comparator1);
          System.out.println(list);
     }
}

1.6 lambda表达式的缩写版

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

1. 小括号内的参数类型可以省略
2. 如果小括号内有且仅有一个参数，则小括号可以省略
3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。

package com.ykq.jdk.lambda03;


public class Test03 {
    public static void main(String[] args) {
//        UserService userService=(String name,int age)->{return name+"~~~~~"+age;};
        UserService userService=(name, age)-> name+"~~~~~"+age       ;//可以省略lambda表达式参数的类型,以及{}和return 和分号；
        goUserService(userService);

//        StudentService studentService=(name)->{ System.out.println("我叫:"+name);};
//        StudentService studentService= name->{ System.out.println("我叫:"+name);}; //int a=15;
        goStudentService(name->{ System.out.println("我叫:"+name);});
    }
    public static void goStudentService(StudentService studentService){
        studentService.print("李白");
    }
    public static void goUserService(UserService userService){//1.方法的参数必须是一个接口类型。 2.该接口有且只有一个抽象方法。
        String s = userService.show("王力宏", 15);
        System.out.println(s);
    }
}
@FunctionalInterface
interface UserService{ //为了防止别人往该接口中添加新的抽象方法，可以使用一个注解FunctionInterface。
    public String show(String name,int age);
    default void fun(){};
}
interface  StudentService{
    public void print(String name);
}

1.7 lambda表达式使用的前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

1. 方法的参数或局部变量类型必须为接口才能使用Lambda
2. 接口中有且仅有一个抽象方法(@FunctionalInterface)
3. 被@FunctionalInterface 修饰后该接口只能有一个抽象方法。