• Java高级篇-----jdk1.8新特性

    1.Lambda表达式

    1.需求分析

    创建一个新的线程，指定线程要执行的任务

    1. package demo01;
    2.  
    3. /**
    4.  * @ProjectName: jdk1.8_1
    5.  * @Package: demo01
    6.  * @ClassName: Test01
    7.  * @Author: 王振华
    8.  * @Description:
    9.  * @Date: 2022/7/19 19:03
    10.  * @Version: 1.0
    11.  */
    12. public class Test01 {
    13.     public static void main(String[] args) {
    14.         My my = new My();
    15.         Thread t1 = new Thread(my);
    16.         t1.start();
    17.  
    18.         //匿名内部类
    19.         Runnable task = new Runnable() {
    20.             @Override
    21.             public void run() {
    22.                 System.out.println("这是使用匿名内部类方法时的任务对象");
    23.             }
    24.         };
    25.         Thread t2 = new Thread(task);
    26.         t2.start();
    27.  
    28.        
    29.     }
    30. }
    31.  
    32. class My implements Runnable{
    33.  
    34.     @Override
    35.     public void run() {
    36.         System.out.println("自定义任务接口类");
    37.     }
    38. }

    代码分析: 


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

    2.Lambda表达式初体验

    Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码

    1. //lambda表达式
    2.         Thread t3 = new Thread(()->{
    3.             System.out.println("这是使用lambda表达式完成的");
    4.         });
    5.         t3.start();

    前提:必须是函数式接口。  

    Lambda表达式的优点:简化了匿名内部类的使用，语法更加简单。
    匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

    3.Lambda的语法规则

    概念:

    Lambda表达式:特殊的匿名内部类,语法更加简洁

    Lambda表达式允许把函数作为一个方法的参数(函数作为方法参数传递),将代码像数据一样传递

    语法:

    <函数式接口> <变量名> = (参数1，参数2...) -> {

            //方法体

    };

    格式说明:

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

    注意:函数式接口:接口中只有一个抽象方法.

    3.1.练习无参无返回值的Lambda表达式

    1. package demo02;
    2.  
    3. /**
    4.  * @ProjectName: jdk1.8_1
    5.  * @Package: demo02
    6.  * @ClassName: Test02
    7.  * @Author: 王振华
    8.  * @Description:
    9.  * @Date: 2022/7/19 19:13
    10.  * @Version: 1.0
    11.  */
    12. //无参无返回值的Lambda表达式
    13. public class Test02 {
    14.     public static void main(String[] args) {
    15.         //匿名内部类
    16.        /* Swimmable swimmable = new Swimmable() {
    17.             @Override
    18.             public void swimming(String name) {
    19.                 System.out.println("这是使用匿名内部类的方式");
    20.             }
    21.         };
    22.         fun(swimmable);*/
    23.  
    24.         //lambda表达式
    25.         fun(name -> {
    26.             System.out.println("这是使用lambda表达式"+name);
    27.         });
    28.     }
    29.     public static void fun(Swimmable s){
    30.         s.swimming("郭富城");
    31.     }
    32. }
    33.  
    34. //函数式接口
    35. interface Swimmable{
    36.     public void swimming(String name);
    37. }

    3.2.练习有参数且有返回值的Lambda表达式

    下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

    • public abstract int compare(T o1, T o2);

    当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。

    1. package demo02;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collections;
    5. import java.util.Comparator;
    6. import java.util.List;
    7.  
    8. /**
    9.  * @ProjectName: jdk1.8_1
    10.  * @Package: demo02
    11.  * @ClassName: Test03
    12.  * @Author: 王振华
    13.  * @Description:
    14.  * @Date: 2022/7/19 19:26
    15.  * @Version: 1.0
    16.  */
    17. //有参有返回值的Lambda表达式
    18. public class Test03 {
    19.     public static void main(String[] args) {
    20.         List list = new ArrayList<>();
    21.         list.add(new Person("张三",20,158));
    22.         list.add(new Person("李四",12,178));
    23.         list.add(new Person("王五",30,167));
    24.         list.add(new Person("赵六",15,184));
    25.  
    26.         //对集合中的元素进行排序  按照年龄从大到小
    27.         //Collections: 集合的工具类   //传统做法:Comparator: 排序规则接口
    28.         Collections.sort(list, new Comparator() {
    29.             //int: 0表示新加的元素和集合中原来的比对的相同
    30. //                 //1: o2比o1大
    31. //                 //-1: o2比o1小
    32.             @Override
    33.             public int compare(Person o1, Person o2) {
    34.                 return o1.getAge()-o2.getAge();
    35.             }
    36.         });
    37.  
    38.         for(Person person : list){
    39.             System.out.println(person);
    40.         }
    41.  
    42.         System.out.println("=================================================");
    43.  
    44.         //使用Lambda表达式   按年龄从小到大
    45.         Collections.sort(list,(o1,o2)->{return o2.getAge()- o1.getAge();});
    46.  
    47.         for(Person person : list){
    48.             System.out.println(person);
    49.         }
    50.  
    51.     }
    52. }
    53.  
    54. class Person{
    55.     private String name;
    56.     private int age;
    57.     private int height;
    58.  
    59.     public Person() {
    60.     }
    61.  
    62.     public Person(String name, int age, int height) {
    63.         this.name = name;
    64.         this.age = age;
    65.         this.height = height;
    66.     }
    67.  
    68.     @Override
    69.     public String toString() {
    70.         return "Person{" +
    71.                 "name='" + name + '\'' +
    72.                 ", age=" + age +
    73.                 ", height=" + height +
    74.                 '}';
    75.     }
    76.  
    77.     public String getName() {
    78.         return name;
    79.     }
    80.  
    81.     public void setName(String name) {
    82.         this.name = name;
    83.     }
    84.  
    85.     public int getAge() {
    86.         return age;
    87.     }
    88.  
    89.     public void setAge(int age) {
    90.         this.age = age;
    91.     }
    92.  
    93.     public int getHeight() {
    94.         return height;
    95.     }
    96.  
    97.     public void setHeight(int height) {
    98.         this.height = height;
    99.     }
    100. }

    3.3.详细介绍Lambda表达式

     2.函数式接口

     内置函数式接口的由来

    1. package demo03;
    2.  
    3. /**
    4.  * @ProjectName: jdk1.8_1
    5.  * @Package: demo03
    6.  * @ClassName: Test03
    7.  * @Author: 王振华
    8.  * @Description:
    9.  * @Date: 2022/7/19 19:43
    10.  * @Version: 1.0
    11.  */
    12. public class Test03 {
    13.     public static void main(String[] args) {
    14.         int[] arr = {2,2,3,4,56,8};
    15.         fun((arr1)->{
    16.             int sum = 0;
    17.             for(int n : arr1){
    18.                 sum += n;
    19.             }
    20.             System.out.println("数组的和:"+sum);
    21.         },arr);
    22.     }
    23.     
    24.     public static void fun(Operater operater,int[] arr){
    25.         operater.getSum(arr);
    26.     }
    27. }
    28. @FunctionalInterface
    29. interface Operater{
    30.     //求数组的和
    31.     public abstract void getSum(int[] arr);
    32. }

    分析

    我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。

    常见得函数式接口

    java.util.function保存

     2.1.Consumer消费型接口

    T:表示参数的泛型

    有参数，无返回值。

    1. package demo04;
    2.  
    3. import java.util.function.Consumer;
    4.  
    5. /**
    6.  * @ProjectName: jdk1.8_1
    7.  * @Package: demo04
    8.  * @ClassName: Test01
    9.  * @Author: 王振华
    10.  * @Description: 消费型接口
    11.  * @Date: 2022/7/19 19:50
    12.  * @Version: 1.0
    13.  */
    14. public class Test01 {
    15.     public static void main(String[] args) {
    16.         fun((t)->{
    17.             System.out.println("花费了"+t+"元");
    18.         },1000);
    19.     }
    20.  
    21.     //调用某个方法时，该方法需要的参数为接口类型，这时就应该能想到Lambda
    22.     public static void fun(Consumer consumer,double money){
    23.         consumer.accept(money);
    24.     }
    25. }

    2.2.Supperlier供给型接口

    T:表示返回结果的泛型

    无参数，有返回值

    1. package demo04;
    2.  
    3. import java.util.Random;
    4. import java.util.function.Supplier;
    5.  
    6. /**
    7.  * @ProjectName: jdk1.8_1
    8.  * @Package: demo04
    9.  * @ClassName: Test02
    10.  * @Author: 王振华
    11.  * @Description: 供给型接口
    12.  * @Date: 2022/7/19 19:56
    13.  * @Version: 1.0
    14.  */
    15. public class Test02 {
    16.     public static void main(String[] args) {
    17.         //0-9的随机整数
    18.         fun(()->{return new Random().nextInt(10);
    19.         });
    20.     }
    21.     public static void fun(Supplier supplier){
    22.         Integer s = supplier.get();
    23.         System.out.println(s);
    24.     }
    25. }

    2.3.Function函数型接口

    T: 参数类型的泛型

    R: 函数返回结果的泛型

    有参数，有返回值。

    例子: 传入一个字符串把小写转换为大写。

    1. package demo04;
    2.  
    3. import java.util.Locale;
    4. import java.util.function.Function;
    5.  
    6. /**
    7.  * @ProjectName: jdk1.8_1
    8.  * @Package: demo04
    9.  * @ClassName: Test03
    10.  * @Author: 王振华
    11.  * @Description: 函数型接口
    12.  * @Date: 2022/7/19 20:01
    13.  * @Version: 1.0
    14.  */
    15. public class Test03 {
    16.     public static void main(String[] args) {
    17.         fun((t)->{
    18.             //转成大写
    19.             return t.toUpperCase();
    20.         },"hello world");
    21.     }
    22.  
    23.     public static void fun(Function function,String msg){
    24.         String apply = function.apply(msg);
    25.         System.out.println(apply);
    26.     }
    27. }

    2.4.Predicate断言型接口

    T: 参数的泛型

    boolean test(T t);

    当传入一个参数时，需要对该参数进行判断时，则需要这种函数。

    1. package demo04;
    2.  
    3. import java.util.function.Predicate;
    4.  
    5. /**
    6.  * @ProjectName: jdk1.8_1
    7.  * @Package: demo04
    8.  * @ClassName: Test04
    9.  * @Author: 王振华
    10.  * @Description: 断言型接口
    11.  * @Date: 2022/7/19 20:04
    12.  * @Version: 1.0
    13.  */
    14. public class Test04 {
    15.     public static void main(String[] args) {
    16.         //判断字符串的长度是否大于3,大于为true，否则相反
    17.         fun((t)->{return t.length()>3;},"会当凌绝顶");
    18.     }
    19.  
    20.     public static void fun(Predicate predicate,String msg){
    21.         boolean test = predicate.test(msg);
    22.         System.out.println(test);
    23.     }
    24. }

     3.方法引用

    3.1.Lambda表达式的冗余

    1. package demo05;
    2.  
    3. import java.util.function.Consumer;
    4.  
    5. /**
    6.  * @ProjectName: jdk1.8_1
    7.  * @Package: demo05
    8.  * @ClassName: Test01
    9.  * @Author: 王振华
    10.  * @Description: Lombda的冗余
    11.  * @Date: 2022/7/19 20:14
    12.  * @Version: 1.0
    13.  */
    14. public class Test01 {
    15.     public static void main(String[] args) {
    16.         fun((t)->{
    17.             String s1 = t.toUpperCase();
    18.             System.out.println(s1);
    19.             },"hello world");
    20.     }
    21.  
    22.     public static void fun(Consumer consumer,String msg){
    23.         consumer.accept(msg);
    24.     }
    25.  
    26.     public static void toUpperCase(String s){
    27.         String s1 = s.toUpperCase();
    28.         System.out.println(s1);
    29.     }
    30. }

    分析:

    我们发现toUpperCase方法和Consumer消费型接口中的代码体此时一致，我们重复写会使代码冗余。

    如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引 用”过去就好了：---方法引用。

    1. package demo05;
    2.  
    3. import java.util.function.Consumer;
    4.  
    5. /**
    6.  * @ProjectName: jdk1.8_1
    7.  * @Package: demo05
    8.  * @ClassName: Test01
    9.  * @Author: 王振华
    10.  * @Description: 
    11.  * @Date: 2022/7/19 20:14
    12.  * @Version: 1.0
    13.  */
    14. public class Test01 {
    15.     public static void main(String[] args) {
    16.         fun((t)->Test01.toUpperCase(t),"hello world");
    17.         fun(Test01::toUpperCase,"hello world");    //这两种 方法是一样的
    18.     }
    19.  
    20.     public static void fun(Consumer consumer,String msg){
    21.         consumer.accept(msg);
    22.     }
    23.  
    24.     public static void toUpperCase(String s){
    25.         String s1 = s.toUpperCase();
    26.         System.out.println(s1);
    27.     }
    28. }

    请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。

    3.2.什么是方法引用

    方法引用的分类

     3.3.静态方法引用

    1. package demo06;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Comparator;
    5. import java.util.List;
    6.  
    7. /**
    8.  * @ProjectName: jdk1.8_1
    9.  * @Package: demo06
    10.  * @ClassName: Test06
    11.  * @Author: 王振华
    12.  * @Description: 静态方法引用
    13.  * @Date: 2022/7/19 21:23
    14.  * @Version: 1.0
    15.  */
    16. public class Test06 {
    17.     public static void main(String[] args) {
    18.         List list = new ArrayList<>();
    19.         list.add(1);
    20.         list.add(3);
    21.         list.add(2);
    22.         list.add(6);
    23.         list.add(4);
    24.  
    25.         //Comparator comparator = ((o1, o2) -> o1-o2);
    26.         
    27.         //Comparator comparator = ((o1, o2) -> Integer.compare(o1,o2));
    28.         //调用了Integer类的静态方法compare方法
    29.         Comparator comparator = Integer::compare;
    30.         list.sort(comparator);
    31.         System.out.println(list);
    32.     }
    33. }

    3.4.实例方法引用

    实例方法引用，顾名思义就是调用已经存在的实例的方法，与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。

    1. package demo07;
    2.  
    3. import java.time.Period;
    4. import java.util.Arrays;
    5. import java.util.Comparator;
    6. import java.util.function.Supplier;
    7.  
    8. /**
    9.  * @ProjectName: jdk1.8_1
    10.  * @Package: demo07
    11.  * @ClassName: Test07
    12.  * @Author: 王振华
    13.  * @Description: 实例方法引用
    14.  * @Date: 2022/7/19 21:31
    15.  * @Version: 1.0
    16.  */
    17. public class Test07 {
    18.     public static void main(String[] args) {
    19.         People[] peoples = {new People("张三",15),new People("李四",12),new People("王五",58),new People("赵六",20)};
    20.         //该数组进行排序---年龄排序int compare(T o1, T o2);
    21.         //Comparator comparator = (o1, o2) -> o1.getAge()-o2.getAge();
    22.  
    23.         //如果在lambda表达式中有且仅有一条语句，而且这条语句是对方法的调用。这时可以考虑使用方法引用
    24.         //Comparator comparator = (o1,o2)-> People.compare(o1,o2);
    25.         Comparator comparator = People::compare;
    26.         Arrays.sort(peoples,comparator);
    27.         System.out.println(Arrays.asList(peoples));
    28.  
    29.         People p=new People("李四",25);
    30.  
    31.         //在这个lambda表达式中只有一条语句，而且这条语句又是调用了某个方法
    32.         //Supplier s=()-> p.getName();
    33.         Supplier s=p::getName;
    34.         fun(s);
    35.     }
    36.     public static void fun(Supplier supplier){
    37.         String s = supplier.get();
    38.         System.out.println("结果为:"+s);
    39.     }
    40. }
    41. class People{
    42.     private String name;
    43.     private int age;
    44.  
    45.     public People(String name, int age) {
    46.         this.name = name;
    47.         this.age = age;
    48.     }
    49.  
    50.     @Override
    51.     public String toString() {
    52.         return "People{" +
    53.                 "name='" + name + '\'' +
    54.                 ", age=" + age +
    55.                 '}';
    56.     }
    57.  
    58.     public static int compare(People p1, People p2){
    59.         return p1.getAge()-p2.getAge();
    60.     }
    61.     public String getName() {
    62.         return name;
    63.     }
    64.  
    65.     public void setName(String name) {
    66.         this.name = name;
    67.     }
    68.  
    69.     public int getAge() {
    70.         return age;
    71.     }
    72.  
    73.     public void setAge(int age) {
    74.         this.age = age;
    75.     }
    76. }

  • 相关阅读:
    MyBatis
    基于Redis实现消息队列的实践
    Swin Transformer、ViT作者等共话：好的基础模型是CV 研究者的朴素追求
    棱镜七彩受邀参加“数字政府建设暨数字安全技术研讨会”
    [算法沉淀记录] 排序算法 —— 希尔排序
    Undefined symbols for architecture arm64
    【腾讯云Cloud Studio实战训练营】戏说cloud studio
    Taro.navigateTo 使用URL传参数和目标页面参数获取
    ESD门禁闸机系统的功能说明
    解决 “ImportError: attempted relative import with no known parent package“ 问题
  • 原文地址：https://blog.csdn.net/weixin_68509156/article/details/125886024