Java新特性

下辈子一定好好学习

Lambda表达式的使用

1. 举例：(o1, o2) -> Integer.compare(o1, o2);

2. 格式：

   ​ ->Lambda操作符或者箭头操作符

   ​ ->Lambda的形参列表（其实就是接口中抽象方法的形参列表）

   ​ ->Lambda体（就是重写抽象方法的方法体）

3. Lambda表达式的使用（6种情况）

4. Lambda表达式的本质：作为接口的实例

语法格式一：

无参、无返回值

import org.junit.Test;
public class pr1 {
    @Test
    public void Test01(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱我家！");
            }
        };
        r1.run();

        System.out.println("**********************************************");

        Runnable r2 = ()->{
            System.out.println("当然，我也爱我家呀！");
        };
        r2.run();
    }
}

语法格式二：

Lambda表达式需要一个参数但是没有返回值

import org.junit.Test;

import java.util.function.Consumer;

public class pr2 {
    @Test
    public void test02(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("你能听懂我所说的话吗？");

        System.out.println("**********************************************");

        Consumer<String> consumer1 = (String s)-> {
            System.out.println(s);
        };
        consumer1.accept("是的呀，我可以听得懂。");
    }
}

语法格式三：

数据类型可以省略，因为可以由编译器推断得出，称为类型推断。

这个让我想起了**var i = 0还有int[] arr = new int[]{3,1,5,9,7}**这个应该也是类型推断吧！！！（算了，就这么记）

import org.junit.Test;

import java.util.function.Consumer;

public class pr3 {
    //类型推断
    @Test
    public void Test03(){
        Consumer<String> consumer = (String s) -> {
            System.out.println(s);
        };
        consumer.accept("A:欲买桂花同载酒下一句是什么？");

        System.out.println("*******************************************");

        Consumer<String> con = (s)-> {
            System.out.println(s);
        };
        con.accept("B:它的下一句是“终不似，少年游");

    }
}

语法格式四：

Lambda只需要一个一个参数的话，参数的那一个小括号可以省略

import org.junit.Test;

import java.util.function.Consumer;

public class pr4 {
    @Test
    public void Test04(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("人生若只如初见");

        System.out.println("*******************************");

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("何事秋风悲画扇");
    }
}

语法格式五：

Lambda表达式需要两个或者以上的参数时候，执行多条语句，并且可以有返回值。

import org.junit.Test;
import java.util.Comparator;
public class pr5 {
    @Test
    public void Test05(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer A, Integer B) {
                System.out.println(A);
                System.out.println(B);
                return A.compareTo(B);
            }
        };
        System.out.println(com1.compare(21,12));

        System.out.println("****************************************");

        Comparator<Integer> com2 = (A,B)-> {
                System.out.println(A);
                System.out.println(B);
                return A.compareTo(B);
            };
        System.out.println(com2.compare(1,12));
    }
}

语法格式六：

当Lambda体只有一条语句的时候，return与大括号若有，则都可以省略

import org.junit.Test;
import java.util.Comparator;
public class pr6 {
    @Test
    public void Test06(){
        Comparator<Integer> con1= (A,B)->{
            return A.compareTo(B);
        };
        System.out.println(con1.compare(21,11));

        System.out.println("****************************");

        Comparator<Integer> con2= (A,B)-> A.compareTo(B);
        System.out.println(con2.compare(21,11));

        System.out.println("****************************");

        Comparator<Integer> con3= Integer::compareTo;
        System.out.println(con3.compare(21,31));
    }
}

例子

compare是compator接口中的一个方法用于比较两个对象

451. 根据字符出现频率排序 - 力扣（LeetCode）

import java.util.*;

public class pr3 {
    public static void main(String[] args) {
        System.out.println(new Solution().frequencySort1("tree"));
    }
}
class Solution {

    public String frequencySort1(String s) {
        Map<Character, Integer> map = new HashMap<>();
        for(char c : s.toCharArray()) map.put(c , map.getOrDefault(c, 0) + 1);
        List<Character> list = new ArrayList<>(map.keySet());

        list.sort(new Comparator<Character>() {
            @Override
            public int compare(Character a, Character b) {
                return map.get(b) - map.get(a);
            }
        });
        //就相当于这一句
//        list.sort((a , b) -> map.get(b) - map.get(a));
        StringBuilder bs = new StringBuilder();
        int len = list.size();
        for (int i = 0; i < len; i++){
            char c = list.get(i);
            int n = map.get(c);
            for (int j = 0; j < n; j++) {
                bs.append(c);
            }
        }
        return bs.toString();
    }
}

这段代码是一个Java程序，其中使用了Lambda表达式。让我们逐步解释这段代码中Lambda表达式的使用：

list.sort(new Comparator<Character>() {
    @Override
    public int compare(Character a, Character b) {
        return map.get(b) - map.get(a);
    }
});

这段代码中的Lambda表达式是用来创建一个比较器（Comparator）。Comparator是一个函数式接口，它定义了一个用于比较两个对象的方法。在这里，我们想要对列表中的字符按照它们在map中对应的值的降序进行排序。

Lambda表达式的部分是：

(Character a, Character b) -> {
    return map.get(b) - map.get(a);
}

让我们逐步解释Lambda表达式的各个部分：

1. (Character a, Character b)：这部分声明了Lambda表达式的参数列表。在这里，我们声明了两个参数a和b，它们的类型都是Character，表示字符对象。

2. ->：箭头符号（->）用来分隔Lambda表达式的参数列表和方法体。

3. {}：这部分是Lambda表达式的方法体。在这里，我们计算了map中b对应的值和map中a对应的值的差值，从而实现了按照值的降序排序。

整个Lambda表达式的功能是创建了一个比较器，用来按照map中字符对应的值的降序对列表中的字符进行排序。

在这个例子中，Lambda表达式使得代码更加简洁，同时提供了对比较器的直接定义，而无需显式地编写一个类来实现Comparator接口。

524. 通过删除字母匹配到字典里最长单词 - 力扣（LeetCode）

class Solution {
    public String findLongestWord(String s, List<String> dictionary) {
        Collections.sort(dictionary,(a, b) ->{
            //如果长度不同，按照长度从大到小进行排序
            if (a.length() != b.length()) return b.length() - a.length();
            //如果长度相同，按照字典序进行排序
            return a.compareTo(b);
        });
        int n = s.length();
        for (String ss : dictionary){
            int m = ss.length();
            int i = 0, j = 0;
            while (i < n && j < m){
                if (s.charAt(i) == ss.charAt(j)) j++;
                i++;
            }
            if (j == m) return ss;
        }
        return "";
    }
}

展开来写就是这样

Collections.sort(dictionary, new Comparator<String>() {
    public int compare(String o1, String o2) {
        if (o1.length() != o2.length()) return o2.length() - o1.length();
        else return o1.compareTo(o2);
    }
});