大哥了解一下Lambda表达式

1.什么是Lambda表达式？
  Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法。
  是一种特殊写法，“核心目的是为了简化匿名内部类的代码写法”。
2.Lambda表达式的格式:
  (匿名内部类被重写方法的形参列表) -> {
   被重写方法的方法体代码。
  }
  -> 就是一个新语法，没有实际含义，但是不能省略！
3.Lambda表达式简化匿名内部类的前提:
  Lambda表达式并不是能简化所有匿名内部类代码的写法。
  Lambda表达式只能简化函数式接口的匿名内部类写法。
    函数式接口:首先必须是接口，其次接口中有且仅有一个抽象方法。
  注意：Lambda表达式只能简化只有一个抽象方法的接口的匿名内部类写法！！
小结：
   Lambda表达式只能简化只有一个抽象方法的接口的匿名内部类写法！！

/**
Lambda表达式的概述。
什么是Lambda表达式？
  Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法。
  是一种特殊写法，“核心目的是为了简化匿名内部类的代码写法”。
Lambda表达式的格式:
  (匿名内部类被重写方法的形参列表) -> {
   被重写方法的方法体代码。
  }
  -> 就是一个新语法，没有实际含义，但是不能省略！
Lambda表达式简化匿名内部类的前提:
  Lambda表达式并不是能简化所有匿名内部类代码的写法。
  Lambda表达式只能简化函数式接口的匿名内部类写法。
    函数式接口:首先必须是接口，其次接口中有且仅有一个抽象方法。
  注意：Lambda表达式只能简化只有一个抽象方法的接口的匿名内部类写法！！
小结：
   Lambda表达式只能简化只有一个抽象方法的接口的匿名内部类写法！！
*/
public class LambdaDemo01 {
  public static void main(String[] args) {
//    Thread t = new Thread(){
//      @Override
//      public void run() {
//        System.out.println(Thread.currentThread().getName());
//      }
//    };
//    Thread t1 = () -> {
//      System.out.println(Thread.currentThread().getName());
//    };
//    t.start();
 }
}

Lambda表达式简化Runnable接口匿名内部类

import java.util.List;
import java.util.function.Consumer;
/**
  目标：Lambda表达式简化Runnable接口的匿名内部类写法
*/
public class LambdaDemo {
  public static void main(String[] args) {
//    Runnable target = new Runnable() {
11Lambda简化Comparator接口匿名内部类写法
//      @Override
//      public void run() {
//        System.out.println(Thread.currentThread().getName());
//      }
//    };
    Runnable  target = () -> {
       System.out.println(Thread.currentThread().getName());
   };
    Thread t = new Thread(target);
    t.start();
    new Thread(() -> {
      System.out.println(Thread.currentThread().getName());
   }).start();
    new Thread(() -> System.out.println(Thread.currentThread().getName())
).start();
 }
}

Lambda简化Comparator接口匿名内部类写法

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
  Lambda简化Comparator接口匿名内部类写法;
*/
public class CollectionsDemo02 {
  public static void main(String[] args) {
    List<Student> lists = new ArrayList<>();
    Student s1 = new Student("小明",10,'男');
    Student s2 = new Student("小红",83,'男');
    Student s3 = new Student("小红花",91,'男');
    Collections.addAll(lists , s1 , s2 , s3);
    /**
      参数一：被排序集合
      参数二：匿名的比较器对象。
         比较器对象会自动提取集合的两两对象让程序员来定制规则排序！！
    */
//    Collections.sort(lists, new Comparator<Student>() {
//      @Override
//      public int compare(Student o1, Student o2) {
//        return o1.getAge() - o2.getAge();
//      }
//    });
    Collections.sort(lists, (Student o1, Student o2) -> {
      return o1.getAge() - o2.getAge();
   });
    Collections.sort(lists, (Student o1, Student o2) ->  o1.getAge() -
o2.getAge());
    Collections.sort(lists, ( o1,  o2) ->  o1.getAge() - o2.getAge());
    System.out.println(lists);
 }
}

import java.util.Objects;
public class Student {
  private String name ;
  private int age ;
  private char sex ;
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
        sex == student.sex &&
        Objects.equals(name, student.name);
 }
  @Override
  public int hashCode() {
    // 只要内容一样，结果地址也一定是一样的！
    return Objects.hash(name, age, sex);
 }
  public Student() {
 }
  public Student(String name, int age, char sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
 }
  public String getName() {
    return name;
 }
  public void setName(String name) {
    this.name = name;
 }
  public int getAge() {
12Lambda表达式的省略写法
    return age;
 }
  public void setAge(int age) {
    this.age = age;
 }
  public char getSex() {
    return sex;
 }
  public void setSex(char sex) {
    this.sex = sex;
 }
  @Override
  public String toString() {
    return "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", sex=" + sex +
        '}';
 }
}

Lambda表达式的省略写法

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
/**
Lambda表达式的省略写法:
  （1）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！
  （2）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是
return
    语句，必须省略return不写，同时也必须省略";"不写
  （3）参数类型可以省略不写。
  （4）如果只有一个参数，参数类型可以省略，同时()也可以省略。
*/
public class LambdaDemo01 {
  public static void main(String[] args) {
    List<String> lists = new ArrayList<>();
    lists.add("java1");
    lists.add("java2");
    lists.add("java3");
    lists.forEach(new Consumer<String>() {
      @Override
      public void accept(String s) {
        System.out.println(s);
     }
   });
13Stream流概述
    lists.forEach((String s) -> {
      System.out.println(s);
   });
    lists.forEach((s) -> {
      System.out.println(s);
   });
    lists.forEach(s -> {
      System.out.println(s);
   });
    lists.forEach(s -> System.out.println(s));
    // 假如前后参数完全一样，可以使用方法引用：对象名称::方法
    lists.forEach(System.out::println);
 }
}