枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~

目录

认识枚举

全文重点：枚举在单例模式中为什么是安全的？

Lambda 表达式

概念：

函数式接口

lambda表达式的基本使用：

lambda表达式的语法精简：

lambda表达式的变量捕获

Lambda在集合当中的使用

在 Collection接口中的使用:

在List中的使用

lambda表达式的总结：

认识枚举

枚举（Enumeration）是一种数据类型，它由一组预定义的常量组成，这些常量通常被称为枚举的成员或枚举值。

枚举的作用，把我们想要描述的东西举例出来，例如颜色。因为在Java中并没有一个特殊的数据类型是表示颜色的。

下列直接列出枚举的简单使用的方法：

  1. enum TestEnum {
  2.     RED,BLACK,GREEN,WHITE;
  3.     public static void main(String[] args) {
  4.         TestEnum testEnum2 = TestEnum.BLACK;
  5.  
  6.  
  7.  
  8.         switch (testEnum2) {
  9.             case RED:
  10.                 System.out.println("red");
  11.                 break;
  12.             case BLACK:
  13.                 System.out.println("black");
  14.                 break;
  15.             case WHITE:
  16.                 System.out.println("WHITE");
  17.                 break;
  18.             case GREEN:
  19.                 System.out.println("black");
  20.                 break;
  21.             default:
  22.                 break;
  23.         }
  24.     }
  25. }

上述场景就是：一个简单使用枚举类型的场景。

从上面代码可以看出枚举：enum 其实有点像类，里面也可以有属性和方法。不同的是enum的第一行必须是你要枚举的常量。否则编译器会直接报错。

带参数的使用案例：

这是带有构造方法的枚举，所以在第一行的枚举常量中我们就必须传参。

注意：枚举的构造方法默认是私有的（重要）

  1. enum TestEnum1 {
  2.     RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
  3.     private String name;
  4.     private int key;
  5.     /**
  6.      * 1、当枚举对象有参数后，需要提供相应的构造函数
  7.      * 2、枚举的构造函数默认是私有的 这个一定要记住
  8.      * @param name
  9.      * @param key
  10.      */
  11.     private TestEnum1 (String name,int key) {
  12.         this.name = name;
  13.         this.key = key;
  14.     }
  15.     public static TestEnum1 getEnumKey (int key) {
  16.  
  17.         for (TestEnum1 t: TestEnum1.values()) {
  18.             if(t.key== key) {
  19.                 return t;
  20.             }
  21.         }
  22.         return null;
  23.     }
  24.     public static void main(String[] args) {
  25.         System.out.println(getEnumKey(2));
  26.     }
  27. }

枚举还有属于自己的的方法：

values() 以数组形式返回枚举类型的所有成员

ordinal() 获取枚举成员的索引位置

valueOf() 将普通字符串转换为枚举实例

compareTo() 比较两个枚举成员在定义时的顺序 

  1.  
  2. enum TestEnum2 {
  3.     RED,BLACK,GREEN,WHITE;
  4.     public static void main(String[] args) {
  5.         TestEnum2[] testEnum2 = TestEnum2.values();
  6.         for (int i = 0; i < testEnum2.length; i++) {
  7.             System.out.println(testEnum2[i] + " " + testEnum2[i].ordinal());
  8.         }
  9.         System.out.println("=========================");
  10.         System.out.println(TestEnum2.valueOf("GREEN"));
  11.     }
  12.  
  13. }

compareTo方法使用案例：

  1. enum TestEnum {
  2.     RED,BLACK,GREEN,WHITE;
  3.     public static void main(String[] args) {
  4. //拿到枚举实例BLACK
  5.         TestEnum testEnum = TestEnum.BLACK;
  6. //拿到枚举实例RED
  7.         TestEnum testEnum21 = TestEnum.RED;
  8.         System.out.println(testEnum.compareTo(testEnum21));
  9.         System.out.println(BLACK.compareTo(RED));
  10.         System.out.println(RED.compareTo(BLACK));
  11.     }
  12. }

枚举的优缺点：

优点：

简单安全，枚举具有内置方法

缺点：无法继承，不可扩展

全文重点：枚举在单例模式中为什么是安全的？

枚举实现单例的安全性基于以下几个原因：

  1. JVM保证的唯一性：枚举类型的每个元素都是静态的，JVM在类加载时会保证每个枚举值只被实例化一次。
  2. 防止反射攻击：尽管理论上可以通过反射创建枚举的额外实例，但是Java语言规范特别指出，尝试通过反射来创建枚举实例的行为是非法的，并且会抛出IllegalArgumentException异常。这意味着即使有人尝试使用反射来破坏单例模式，JVM也会阻止这种行为，从而保持枚举实现的单例模式的线程安全性。
  3. 序列化安全：枚举类型是不可变的，并且JVM在反序列化时会保证枚举实例的唯一性，这使得枚举实现的单例在序列化和反序列化过程中也是安全的。

那么接下来我们就重点解析一下第二点：枚举是怎么防止反射攻击？

下面我们尝试一下反射获取构造方法，并尝试实例化出一个对象。

  1. enum TestEnum1 {
  2.     RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
  3.     private String name;
  4.     private int key;
  5.     /**
  6.      * 1、当枚举对象有参数后，需要提供相应的构造函数
  7.      * 2、枚举的构造函数默认是私有的 这个一定要记住
  8.      * @param name
  9.      * @param key
  10.      */
  11.     private TestEnum1 (String name,int key) {
  12.         this.name = name;
  13.         this.key = key;
  14.     }
  15.     public static TestEnum1 getEnumKey (int key) {
  16.  
  17.         for (TestEnum1 t: TestEnum1.values()) {
  18.             if(t.key== key) {
  19.                 return t;
  20.             }
  21.         }
  22.         return null;
  23.     }
  24.  
  25.  
  26.  
  27.     public static void reflectPrivateConstructor() {
  28.         try {
  29.             Class<?> classStudent = Class.forName("TestEnum");
  30. //注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int。
  31.             Constructor<?> declaredConstructorStudent= classStudent.getDeclaredConstructor(String.class, int.class);
  32. //设置为true后可修改访问权限
  33.             declaredConstructorStudent.setAccessible(true);
  34.             Object objectStudent = declaredConstructorStudent.newInstance("绿色",666);
  35.             TestEnum testEnum = (TestEnum) objectStudent;
  36.             System.out.println("获得枚举的私有构造函数："+testEnum);
  37.         } catch (Exception ex) {
  38.             ex.printStackTrace();
  39.         }
  40.  
  41.  
  42.  
  43.     }

显然编译器已经报错，并直接给出提示，不能通过反射，创建出一个枚举实例。

那么我们就看一下源码，来看看代码是怎样抛出异常，阻止反射枚举获取实例。

跳转到源码当中就发现了，(clazz.getModifiers() & Modifier.ENUM) != 0，的第二个条件直接忽略了枚举，当Constructor中发现反射对象为枚举时，就直接抛出异常了。这就是枚举实现单例模式时安全的原因之一。

Lambda 表达式

概念：

Lambda表达式在Java中是一种重要的高级特性，它允许开发者以更简洁的方式定义和使用函数，特别是在处理集合和多线程编程时提供了更为简洁和高效的解决方案。

  1. 历史背景：Lambda表达式作为一种函数式编程的概念，最早由Alonzo Church在其λ演算中提出。Java在2014年发布的Java 8中正式引入了Lambda表达式，标志着Java向函数式编程迈出了重要一步。
  2. 引入原因：在Java 8之前，Java主要是一种面向对象的编程语言。在处理特定场景，如事件监听器或集合的排序时，需要创建大量的匿名内部类，这增加了代码的复杂性，降。
  3. 语法格式：Lambda表达式的语法格式非常简洁，通常由参数列表、箭头符号（->）和表达式体三部分组成。参数列表定义了传递给Lambda函数的参数，箭头符号表示参数列表的结束，表达式体则是Lambda函数执行的代码。例如:

(parameters) -> expression(表达式)

(parameters) ->{ statements; } (代码块)

这里把expression和statements统称为方法体

方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反 回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

lambda表达式代码示例：

  1. // 1. 不需要参数,返回值为 2
  2. () -> 2
  3. // 2. 接收一个参数(数字类型),返回其2倍的值
  4. x -> 2 * x
  5. // 3. 接受2个参数(数字),并返回他们的和
  6. (x, y) -> x + y
  7. // 4. 接收2个int型整数,返回他们的乘积
  8. (int x, int y) -> x * y
  9. // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
  10. (String s) -> System.out.print(s)
  11. @FunctionalInterface
  12. interface NoParameterNoReturn {
  13.     //注意：只能有一个方法
  14.     void test();
  15. }

那么lambda表达式在哪使用，怎么使用呢？那么我们就需要先认识函数式接口！！！

函数式接口

  1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
  2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

定义方式（两种）： 

  1. interface NoParameterNoReturn {
  2.     //注意：只能有一个方法
  3.     void test();
  4. }

或：

  1. @FunctionalInterface
  2. interface NoParameterNoReturn {
  3.     void test();
  4.     default void test2() {
  5.         System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
  6.     }
  7. }

可以简单理解为：lambda就是用来简化函数式接口的使用。

lambda表达式的基本使用：

不使用lambda表达式的形式：

  1. @FunctionalInterface
  2. interface NoParameterNoReturn {
  3.     void test();
  4. }
  5.  
  6.  
  7. public  class T{
  8.     public static void main(String[] args) {
  9.  
  10.         NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
  11.             @Override
  12.             public void test() {
  13.                 System.out.println("hello");
  14.             }
  15.         };
  16.         noParameterNoReturn.test();
  17.     }
  18. }

向上面的代码，就略显麻烦。下面就展示各种接口的lambda表达式的使用方法：

以下还不是最精简的lambda表达式：

  1.  
  2. //无返回值无参数
  3. @FunctionalInterface
  4. interface NoParameterNoReturn {
  5.     void test();
  6. }
  7. //无返回值一个参数
  8. @FunctionalInterface
  9. interface OneParameterNoReturn {
  10.     void test(int a);
  11. }
  12. //无返回值多个参数
  13. @FunctionalInterface
  14. interface MoreParameterNoReturn {
  15.     void test(int a,int b);
  16. }
  17. //有返回值无参数
  18. @FunctionalInterface
  19. interface NoParameterReturn {
  20.     int test();
  21. }
  22. //有返回值一个参数
  23. @FunctionalInterface
  24. interface OneParameterReturn {
  25.     int test(int a);
  26. }
  27. //有返回值多参数
  28. @FunctionalInterface
  29. interface MoreParameterReturn {
  30.     int test(int a,int b);
  31. }
  32.  
  33.  
  34.  
  35. public  class T{
  36.  
  37.     public class TestDemo {
  38.         public static void main(String[] args) {
  39.             NoParameterNoReturn noParameterNoReturn = ()->{
  40.                 System.out.println("无参数无返回值");
  41.             };
  42.             noParameterNoReturn.test();
  43.             OneParameterNoReturn oneParameterNoReturn = (int a)->{
  44.                 System.out.println("一个参数无返回值："+ a);
  45.             };
  46.             oneParameterNoReturn.test(10);
  47.             MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
  48.                 System.out.println("多个参数无返回值："+a+" "+b);
  49.             };
  50.             moreParameterNoReturn.test(20,30);
  51.             NoParameterReturn noParameterReturn = ()->{
  52.                 System.out.println("有返回值无参数！");
  53.                 return 40;
  54.             };
  55. //接收函数的返回值
  56.             int ret = noParameterReturn.test();
  57.             System.out.println(ret);
  58.             OneParameterReturn oneParameterReturn = (int a)->{
  59.                 System.out.println("有返回值有一个参数！");
  60.                 return a;
  61.             };
  62.             ret = oneParameterReturn.test(50);
  63.             System.out.println(ret);
  64.             MoreParameterReturn moreParameterReturn = (int a,int b)->{
  65.                 System.out.println("有返回值多个参数！");
  66.                 return a+b;
  67.             };
  68.             ret = moreParameterReturn.test(60,70);
  69.             System.out.println(ret);
  70.         }
  71.     }
  72. }

lambda表达式的语法精简：

  1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
  2. 参数的小括号里面只有一个参数，那么小括号可以省略
  3. 如果方法体当中只有一句代码，那么大括号可以省略
  4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

  1. public static void main(String[] args) {
  2.     MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
  3.         System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
  4.     };
  5.     moreParameterNoReturn.test(20,30);
  6.     
  7.     OneParameterNoReturn oneParameterNoReturn = a ->{
  8.         System.out.println("一个参数无返回值,小括号可以胜率："+ a);
  9.     };
  10.     oneParameterNoReturn.test(10);
  11.     
  12.     NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有一行代码");
  13.     noParameterNoReturn.test();
  14.     
  15. //方法体中只有一条语句，且是return语句
  16.     NoParameterReturn noParameterReturn = ()-> 40;
  17.     int ret = noParameterReturn.test();
  18.     System.out.println(ret);
  19. }

以上就是精简过后的lambda表达式。

lambda表达式的变量捕获

在下面代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用 之前，没有修改。如下代码就是错误的代码 ：

Lambda在集合当中的使用

在 Collection接口中的使用:

正常用法：

  1. public static void main(String[] args) {
  2.     ArrayList<String> list = new ArrayList<>();
  3.     list.add("Hello");
  4.     list.add("bit");
  5.     list.add("hello");
  6.     list.add("lambda");
  7.     list.forEach(new Consumer<String>(){
  8.         @Override
  9.         public void accept(String str){
  10. //简单遍历集合中的元素。
  11.             System.out.print(str+" ");
  12.         }
  13.     });
  14. }

使用lambda表达式：

相当于实现了Consumer中的 void accept(String str)方法。

  1. public static void main(String[] args) {
  2.     ArrayList<String> list = new ArrayList<>();
  3.     list.add("Hello");
  4.     list.add("bit");
  5.     list.add("hello");
  6.     list.add("lambda");
  7. //表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
  8.     list.forEach(s -> {
  9.         System.out.println(s);
  10.     });
  11. }

在List中的使用

正常使用方法：

  1. public static void main(String[] args) {
  2.     ArrayList<String> list = new ArrayList<>();
  3.     list.add("Hello");
  4.     list.add("bit");
  5.     list.add("hello");
  6.     list.add("lambda");
  7.     list.sort(new Comparator<String>() {
  8.         @Override
  9.         public int compare(String str1, String str2) {
  10. //注意这里比较长度
  11.             return str1.length() - str2.length();
  12.         }
  13.     });
  14.     System.out.println(list);
  15. }

lambda表示式用法：

相当于实现了Comparator中的int compare(String str1, String str2)方法

  1. public static void main(String[] args) {
  2.     ArrayList<String> list = new ArrayList<>();
  3.     list.add("Hello");
  4.     list.add("bit");
  5.     list.add("hello");
  6.     list.add("lambda");
  7. //调用带有2个参数的方法，且返回长度的差值
  8.     list.sort((str1, str2) -> str1.length() - str2.length());
  9.     System.out.println(list);
  10. }

lambda表达式的总结：

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。
优点：

  1. 代码简洁，开发迅速
  2. 方便函数式编程
  3. 非常容易进行并行计算
  4. Java 引入 Lambda，改善了集合操作
    缺点：
  5. 代码可读性变差
  6. 在非并行计算中，很多计算未必有传统的 for 性能要高
  7. 不容易进行调试
注：本文转载自blog.csdn.net的Gu Gu Study的文章"https://blog.csdn.net/2302_81249757/article/details/143881468"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！