Java 使用函数式编程替代反射

在特定场景下，使用函数式编程代替反射可以简化代码，提高代码执行效率。

以前，我在工作中遇到一个场景，需要将可变长度的数组依次分配给对象的某些字段。当时的解决方案是使用反射，在更好地理解函数式编程之后，可以使用反射。

反射需要解析字节码，效率不高；需要处理已检查的异常；更多代码。推荐使用函数式编程。

测试代码如下所示。测试代码如下所示。测试代码如下。

 1 package demo; 2 
 3 import java.lang.reflect.InvocationTargetException; 4 import java.lang.reflect.Method; 5 import java.util.Arrays; 6 import java.util.List; 7 import java.util.function.BiConsumer; 8 import java.util.stream.IntStream; 9 
10 public class Test01 {
11 
12     static String[] arr = { "str01", "str02", "str03", "str04", "str05", "str06", "str07", "str08", "str09", "str10" };
13 
14     static List> biConsumers = Arrays.asList(Item::setVar1, Item::setVar2, Item::setVar3,
15 Item::setVar4, Item::setVar5, Item::setVar6, Item::setVar7, Item::setVar8, Item::setVar9, Item::setVar10);
16 
17     public static void main(String[] args) {
18         long start = System.currentTimeMillis();
19         IntStream.range(0, 10000).forEach(i -> testReflect());
20         long end = System.currentTimeMillis();
21         System.out.println(end - start);
22 
23         long start1 = System.currentTimeMillis();
24         IntStream.range(0, 10000).forEach(i -> testMethodReference());
25         long end1 = System.currentTimeMillis();
26 
27         System.out.println(end1 - start1);
28 }
29 
30     static void testReflect() {
31         Item item = new Item();
32 
33         try {
34             Class clazz = Class.forName("demo.Item");
35             for (int i = 0; i < arr.length - 1; i++) {
36                 Method method = clazz.getMethod("setVar" + (i + 1), String.class);
37                 method.invoke(item, arr[0]);
38 }
39 
40         } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException
41                 | IllegalArgumentException | InvocationTargetException e) {
42 e.printStackTrace();
43 }
44 }
45 
46     static void testMethodReference() {
47         Item item = new Item();
48 
49         for (int i = 0; i < arr.length; i++) {
50 biConsumers.get(i).accept(item, arr[i]);
51 }
52 }
53 }

一个简单的基准测试结果：速度更差10倍

 1 package demo; 2 
 3 public class Item { 4     private String var1; 5     private String var2; 6     private String var3; 7     private String var4; 8     private String var5; 9     private String var6;
10     private String var7;
11     private String var8;
12     private String var9;
13     private String var10;
14 
15     public String getVar1() {
16         return var1;
17 }
18 
19     public void setVar1(String var1) {
20         this.var1 = var1;
21 }
22 
23     public String getVar2() {
24         return var2;
25 }
26 
27     public void setVar2(String var2) {
28         this.var2 = var2;
29 }
30 
31     public String getVar3() {
32         return var3;
33 }
34 
35     public void setVar3(String var3) {
36         this.var3 = var3;
37 }
38 
39     public String getVar4() {
40         return var4;
41 }
42 
43     public void setVar4(String var4) {
44         this.var4 = var4;
45 }
46 
47     public String getVar5() {
48         return var5;
49 }
50 
51     public void setVar5(String var5) {
52         this.var5 = var5;
53 }
54 
55     public String getVar6() {
56         return var6;
57 }
58 
59     public void setVar6(String var6) {
60         this.var6 = var6;
61 }
62 
63     public String getVar7() {
64         return var7;
65 }
66 
67     public void setVar7(String var7) {
68         this.var7 = var7;
69 }
70 
71     public String getVar8() {
72         return var8;
73 }
74 
75     public void setVar8(String var8) {
76         this.var8 = var8;
77 }
78 
79     public String getVar9() {
80         return var9;
81 }
82 
83     public void setVar9(String var9) {
84         this.var9 = var9;
85 }
86 
87     public String getVar10() {
88         return var10;
89 }
90 
91     public void setVar10(String var10) {
92         this.var10 = var10;
93 }
94 }

View Code

另外，当前场景可以通过存储来存储Method以避免在每个循环中重新执行反射，从而提高效率，但不会避免检查的异常。也有可能通过if-else判断可能导致繁琐的代码，可以避免异常处理。

两者都不像方法引用那样简洁和有效。

转载于:https://www.cnblogs.com/blouson/p/11258770.html