JDK1.8新特新之lambda表达式

什么是lambda表达式

lambda表达式时java8的提供的一种新的特性，支持Java进行简单的“函数时编程”，它是一个匿名函数。Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda 是一个匿名函数，可以把 Lambda表达式 理解为是一段可以传递的代码 (将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 ，JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效

1. lambda表达式：是一种特殊的匿名内部类，语法更简洁。

2. lambda表达式允许将函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。

3. 基本语法：

   ​ <函数式接口> <变量名> = （参数1，参数2…）{

   ​ //方法体

   ​ }

4. lambda引入了新的操作符：->（箭头操作符），->将表达式分成两部分

   1. 左侧：（参数1，参数2…）表示参数列表
   2. 右侧：{}内部是方法体

5. 注意事项：

   1. 形参列表的数据类型会走动推断
   2. 如果形参列表为空，只需保留参数的名称即可
   3. 如果形参只有一个，（）可以省略，只需参数的名称即可
   4. 如果执行语句只有一句时，且无返回值，{}可以省略，如果返回值，则若想省区{}，则必须同时省略return，且执行语句也保证只有一句
   5. lambda不会生成一个单独的内部类文件

示例：

package com.hong.lambda;

/**
 * @Author hongCheng
 * @Date 2021/4/25 14:20
 * @Version 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {//匿名内部类对象
            //实现接口中的方法
            @Override
            public void run() {
                System.out.println("这是使用匿名内部类的方式");
            }
        };

        Thread thread = new Thread(runnable);//Runnable target
        thread.start();//启动线程---》执行run方法

        //改进①  jdk1.8 里面的方式就一个方式  表达式  ->
        //(方法的形成)->{方法体} 必须接口中只有一个抽象方法
        Runnable runnable1 = () -> {
            System.out.println("这是lambda表达式的是：改进①");
        };

        Thread thread1 = new Thread(runnable1);
        thread1.start();

        //改进②
        //如果方法体中只有一条语句，那么直接就可以省略{}
        Runnable runnable2 = () -> System.out.println("这是lambda表达式的方式：改进②");
        Thread thread2 = new Thread(runnable2);
        thread2.start();

        //改进③
        //thread中传递的runnable对象，那么直接可以将表达式放入thread中

        Thread thread3 = new Thread(()-> System.out.println("这是lambda表达式的方式：改进③"),"");
        thread3.start();

    }
}

使用比较器比较

package com.hong.lambda;

import com.sun.org.apache.xalan.internal.xsltc.trax.XSLTCSource;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @Author hongCheng
 * @Date 2021/4/25 15:02
 * @Version 1.0
 */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<String> strings = new TreeSet<>();//TreeSet具有排序功能，通过自然排序
        strings.add("java04");
        strings.add("java03");
        strings.add("java02");
        strings.add("java05");
        strings.add("java01");
        System.out.println(strings);

        /*System.out.println("=============比较器比较Comparable=============");
        TreeSet<Person> people = new TreeSet<>();
        people.add(new Person(1, "红红"));
        people.add(new Person(2, "冬冬"));
        people.add(new Person(3, "橙子"));
        people.add(new Person(4, "杉杉"));
        System.out.println(people);*/

        System.out.println("===============使用Comparator============");
        Comparator<Person> comparator = new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                return o1.getId() - o2.getId();
            }
        };

        TreeSet<Person> treeSet = new TreeSet<>(comparator);//Comparator<? super E> comparator:需要自定义排序
        treeSet.add(new Person(3, "红红"));
        treeSet.add(new Person(1, "冬冬"));
        treeSet.add(new Person(4, "橙子"));
        treeSet.add(new Person(2, "杉杉"));
        System.out.println(treeSet);

        System.out.println("=======Comparator改进①=======");
		//Comparator 在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法
        Comparator<Person> comparator1 = (o1, o2) -> {
            return o1.getId() - o2.getId();
        };
        TreeSet<Person> treeSet1 = new TreeSet<>(comparator1);//Comparator<? super E> comparator:需要自定义排序
        treeSet1.add(new Person(3, "红红"));
        treeSet1.add(new Person(1, "冬冬"));
        treeSet1.add(new Person(4, "橙子"));
        treeSet1.add(new Person(2, "杉杉"));
        System.out.println(treeSet1);

        System.out.println("=====Comparator改进②=====");
        Comparator<Person> comparator2 = (o1, o2) -> o1.getId() - o2.getId();

        TreeSet<Person> treeSet2 = new TreeSet<>(comparator2);//Comparator<? super E> comparator:需要自定义排序
        treeSet2.add(new Person(3, "红红"));
        treeSet2.add(new Person(1, "冬冬"));
        treeSet2.add(new Person(4, "橙子"));
        treeSet2.add(new Person(2, "杉杉"));
        System.out.println(treeSet2);

        System.out.println("=====Comparator改进③=====");
        TreeSet<Person> treeSet3 = new TreeSet<>((o1, o2)-> o1.getId() - o2.getId());//Comparator<? super E> comparator:需要自定义排序
        treeSet3.add(new Person(3, "红红"));
        treeSet3.add(new Person(1, "冬冬"));
        treeSet3.add(new Person(4, "橙子"));
        treeSet3.add(new Person(2, "杉杉"));
        System.out.println(treeSet3);
    }
}

//Comparable:自然比较器 要求类必须实现Comparable接口。如果该类没有实现Comparable接口那么就会报错
//Comparable:在集合内部定义的方法实现的排序
@Data
@NoArgsConstructor
@AllArgsConstructor
class Person {//implements Comparable<Person>
    private Integer id;
    private String name;

    /*//如果两个元素相同返回0  >0表示大
    @Override
    public int compareTo(Person o) {
        System.out.println(this.name+"----->"+o.name);
        return 1;
    }*/
}