请不要再说Java中final方法比非final性能更好了

最新推荐文章于 2024-09-03 17:13:27 发布
最新推荐文章于 2024-09-03 17:13:27 发布
阅读量318 收藏
点赞数

640?wx_fmt=jpeg

无继承

有 static 修饰

static final
// 生成随机数字和字母,	
    public static final String getStringRandomFinal(int length) {	
        String val = "";	
        Random random = new Random();	
        // 参数length，表示生成几位随机数	
        for (int i = 0; i < length; i++) {	
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";	
            // 输出字母还是数字	
            if ("char".equalsIgnoreCase(charOrNum)) {	
                // 输出是大写字母还是小写字母	
                // int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;	
                val += (char) (random.nextInt(26) + 97);	
            } else if ("num".equalsIgnoreCase(charOrNum)) {	
                val += String.valueOf(random.nextInt(10));	
            }	
        }	
        return val;	
    }
static 非 final
// 生成随机数字和字母,	
    public static String getStringRandom(int length) {	
        String val = "";	
        Random random = new Random();	
        // 参数length，表示生成几位随机数	
        for (int i = 0; i < length; i++) {	
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";	
            // 输出字母还是数字	
            if ("char".equalsIgnoreCase(charOrNum)) {	
                // 输出是大写字母还是小写字母	
                // int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;	
                val += (char) (random.nextInt(26) + 97);	
            } else if ("num".equalsIgnoreCase(charOrNum)) {	
                val += String.valueOf(random.nextInt(10));	
            }	
        }	
        return val;	
    }
结果

这里使用了 OpenJDK 的 JMH 基准测试工具来测试的，结果如下:

# JMH 1.4.1 (released 903 days ago, please consider updating!)	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmark	
中间忽略了预热及测试过程，这里只显示结果	
Result: 206924.113 ±(99.9%) 7746.446 ops/s [Average]	
  Statistics: (min, avg, max) = (132107.466, 206924.113, 267265.397), stdev = 32798.937	
  Confidence interval (99.9%): [199177.667, 214670.559]	
# JMH 1.4.1 (released 903 days ago, please consider updating!)	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmarkFinal	
中间忽略了预热及测试过程，这里只显示结果	
Result: 210111.568 ±(99.9%) 8486.176 ops/s [Average]	
  Statistics: (min, avg, max) = (133813.368, 210111.568, 267525.228), stdev = 35931.001	
  Confidence interval (99.9%): [201625.392, 218597.744]	
# Run complete. Total time: 00:13:54	
Benchmark                       Mode  Samples       Score      Error  Units	
o.a.s.j.Main.benchmark         thrpt      200  206924.113 ± 7746.446  ops/s	
o.a.s.j.Main.benchmarkFinal    thrpt      200  210111.568 ± 8486.176  ops/s

总结：你说final的性能比非final有没有提升呢？可以说有，但几乎可以忽略不计。如果单纯地追求性能，而将所有的方法修改为 final 的话，我认为这样子是不可取的。

而且这性能的差别，远远也没有网上有些人说的提升 50% 这么恐怖（有可能他们使用的是10年前的JVM来测试的吧^_^，比如 《35+ 个 Java 代码性能优化总结》这篇文章。雷总：不服？咱们来跑个分！）

分析

字节码级别的差别
StringKit.java StringKitFinal.java

它们在字节码上的差别:

[18:52:08] emacsist:target $ diff /tmp/stringkit.log /tmp/stringkit-final.log	
1,5c1,5	
< Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKit.class	
<   Last modified 2017-6-15; size 1098 bytes	
<   MD5 checksum fe1ccdde26107e4037afc54c780f2c95	
<   Compiled from "StringKit.java"	
< public class org.agoncal.sample.jmh.StringKit	
---	
> Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKitFinal.class	
>   Last modified 2017-6-15; size 1118 bytes	
>   MD5 checksum 410f8bf0eb723b794e4754c6eb8b9829	
>   Compiled from "StringKitFinal.java"	
> public class org.agoncal.sample.jmh.StringKitFinal	
24c24	
<   #15 = Class              #52            // org/agoncal/sample/jmh/StringKit	
---	
>   #15 = Class              #52            // org/agoncal/sample/jmh/StringKitFinal	
32,33c32,33	
<   #23 = Utf8               Lorg/agoncal/sample/jmh/StringKit;	
<   #24 = Utf8               getStringRandom	
---	
>   #23 = Utf8               Lorg/agoncal/sample/jmh/StringKitFinal;	
>   #24 = Utf8               getStringRandomFinal	
47c47	
<   #38 = Utf8               StringKit.java	
---	
>   #38 = Utf8               StringKitFinal.java	
61c61	
<   #52 = Utf8               org/agoncal/sample/jmh/StringKit	
---	
>   #52 = Utf8               org/agoncal/sample/jmh/StringKitFinal	
75c75	
<   public org.agoncal.sample.jmh.StringKit();	
---	
>   public org.agoncal.sample.jmh.StringKitFinal();	
87c87	
<             0       5     0  this   Lorg/agoncal/sample/jmh/StringKit;	
---	
>             0       5     0  this   Lorg/agoncal/sample/jmh/StringKitFinal;	
89c89	
<   public static java.lang.String getStringRandom(int);	
---	
>   public static final java.lang.String getStringRandomFinal(int);	
91c91	
<     flags: ACC_PUBLIC, ACC_STATIC	
---	
>     flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL	
187c187	
< SourceFile: "StringKit.java"	
---	
> SourceFile: "StringKitFinal.java"

可以看到除了方法名和方法修饰符不同之外，其他的没有什么区别了。

在调用者上面的字节码差别

 public void benchmark();	
    descriptor: ()V	
    flags: ACC_PUBLIC	
    Code:	
      stack=1, locals=1, args_size=1	
         0: bipush        32	
         2: invokestatic  #2                  // Method org/agoncal/sample/jmh/StringKit.getStringRandom:(I)Ljava/lang/String;	
         5: pop	
         6: return	
      LineNumberTable:	
        line 21: 0	
        line 22: 6	
      LocalVariableTable:	
        Start  Length  Slot  Name   Signature	
            0       7     0  this   Lorg/agoncal/sample/jmh/Main;	
    RuntimeVisibleAnnotations:	
      0: #26()	
  public void benchmarkFinal();	
    descriptor: ()V	
    flags: ACC_PUBLIC	
    Code:	
      stack=1, locals=1, args_size=1	
         0: bipush        32	
         2: invokestatic  #3                  // Method org/agoncal/sample/jmh/StringKitFinal.getStringRandomFinal:(I)Ljava/lang/String;	
         5: pop	
         6: return	
      LineNumberTable:	
        line 26: 0	
        line 27: 6	
      LocalVariableTable:	
        Start  Length  Slot  Name   Signature	
            0       7     0  this   Lorg/agoncal/sample/jmh/Main;	
    RuntimeVisibleAnnotations:	
      0: #26()

可以看到，它们在调用者上面的字节码也没有什么区别，只是方法名不一样之外。

对于 JVM 来说，它是只认字节码的，既然字节码除了方法名和修饰符一样，其他都一样，那就可以大概推测它们的性能几乎可以忽略不计了。因为调用 static final 和 static 非 final 的JVM指令是一样。

无 static 修饰

方法体是一样的，只是将它们删除了 static 的修饰。

结果

# JMH version: 1.19	
# VM version: JDK 1.8.0_92, VM 25.92-b14	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmark	
中间忽略了预热及测试过程，这里只显示结果	
Result "org.agoncal.sample.jmh.Main.benchmark":	
  201306.770 ±(99.9%) 8184.423 ops/s [Average]	
  (min, avg, max) = (131889.934, 201306.770, 259928.172), stdev = 34653.361	
  CI (99.9%): [193122.347, 209491.193] (assumes normal distribution)	
# JMH version: 1.19	
# VM version: JDK 1.8.0_92, VM 25.92-b14	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmarkFinal	
中间忽略了预热及测试过程，这里只显示结果	
Result "org.agoncal.sample.jmh.Main.benchmarkFinal":	
  196871.022 ±(99.9%) 8595.719 ops/s [Average]	
  (min, avg, max) = (131182.268, 196871.022, 265522.769), stdev = 36394.814	
  CI (99.9%): [188275.302, 205466.741] (assumes normal distribution)	
# Run complete. Total time: 00:13:35	
Benchmark             Mode  Cnt       Score      Error  Units	
Main.benchmark       thrpt  200  201306.770 ± 8184.423  ops/s	
Main.benchmarkFinal  thrpt  200  196871.022 ± 8595.719  ops/s

分析

字节码级别的差别
[19:20:17] emacsist:target $ diff /tmp/stringkit.log /tmp/stringkit-final.log	
1,5c1,5	
< Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKit.class	
<   Last modified 2017-6-15; size 1110 bytes	
<   MD5 checksum f61144e86f7c17dc5d5f2b2d35fac36d	
<   Compiled from "StringKit.java"	
< public class org.agoncal.sample.jmh.StringKit	
---	
> Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKitFinal.class	
>   Last modified 2017-6-15; size 1130 bytes	
>   MD5 checksum 15ce17ee17fdb5f4721f0921977b1e69	
>   Compiled from "StringKitFinal.java"	
> public class org.agoncal.sample.jmh.StringKitFinal	
24c24	
<   #15 = Class              #52            // org/agoncal/sample/jmh/StringKit	
---	
>   #15 = Class              #52            // org/agoncal/sample/jmh/StringKitFinal	
32,33c32,33	
<   #23 = Utf8               Lorg/agoncal/sample/jmh/StringKit;	
<   #24 = Utf8               getStringRandom	
---	
>   #23 = Utf8               Lorg/agoncal/sample/jmh/StringKitFinal;	
>   #24 = Utf8               getStringRandomFinal	
47c47	
<   #38 = Utf8               StringKit.java	
---	
>   #38 = Utf8               StringKitFinal.java	
61c61	
<   #52 = Utf8               org/agoncal/sample/jmh/StringKit	
---	
>   #52 = Utf8               org/agoncal/sample/jmh/StringKitFinal	
75c75	
<   public org.agoncal.sample.jmh.StringKit();	
---	
>   public org.agoncal.sample.jmh.StringKitFinal();	
87c87	
<             0       5     0  this   Lorg/agoncal/sample/jmh/StringKit;	
---	
>             0       5     0  this   Lorg/agoncal/sample/jmh/StringKitFinal;	
89c89	
<   public java.lang.String getStringRandom(int);	
---	
>   public final java.lang.String getStringRandomFinal(int);	
91c91	
<     flags: ACC_PUBLIC	
---	
>     flags: ACC_PUBLIC, ACC_FINAL	
169c169	
<             0     125     0  this   Lorg/agoncal/sample/jmh/StringKit;	
---	
>             0     125     0  this   Lorg/agoncal/sample/jmh/StringKitFinal;	
188c188	
< SourceFile: "StringKit.java"	
---	
> SourceFile: "StringKitFinal.java"

可以看到，字节码上除了名字和 final 修饰符差别外，其余的是一样的。

在调用者上面的字节码差别

public void benchmark();	
    descriptor: ()V	
    flags: ACC_PUBLIC	
    Code:	
      stack=2, locals=1, args_size=1	
         0: new           #2                  // class org/agoncal/sample/jmh/StringKit	
         3: dup	
         4: invokespecial #3                  // Method org/agoncal/sample/jmh/StringKit."<init>":()V	
         7: bipush        32	
         9: invokevirtual #4                  // Method org/agoncal/sample/jmh/StringKit.getStringRandom:(I)Ljava/lang/String;	
        12: pop	
        13: return	
      LineNumberTable:	
        line 21: 0	
        line 22: 13	
      LocalVariableTable:	
        Start  Length  Slot  Name   Signature	
            0      14     0  this   Lorg/agoncal/sample/jmh/Main;	
    RuntimeVisibleAnnotations:	
      0: #30()	
  public void benchmarkFinal();	
    descriptor: ()V	
    flags: ACC_PUBLIC	
    Code:	
      stack=2, locals=1, args_size=1	
         0: new           #5                  // class org/agoncal/sample/jmh/StringKitFinal	
         3: dup	
         4: invokespecial #6                  // Method org/agoncal/sample/jmh/StringKitFinal."<init>":()V	
         7: bipush        32	
         9: invokevirtual #7                  // Method org/agoncal/sample/jmh/StringKitFinal.getStringRandomFinal:(I)Ljava/lang/String;	
        12: pop	
        13: return	
      LineNumberTable:	
        line 26: 0	
        line 27: 13	
      LocalVariableTable:	
        Start  Length  Slot  Name   Signature	
            0      14     0  this   Lorg/agoncal/sample/jmh/Main;	
    RuntimeVisibleAnnotations:	
      0: #30()

可以看到，它们除了名字不同之外，其他的JVM指令都是一样的。

总结

对于是否有 final 修饰的方法，对性能的影响可以忽略不计。因为它们生成的字节码除了 flags 标志位是否有 final 修饰不同之外，其他所有的JVM指令，都是一样的（对于方法本身，以及调用者本身的字节码都一样）。对于JVM来说，它执行的就是字节码，如果字节码都一样的话，那对于JVM来说，它就是同一样东西的了。

有继承

无 final 修饰
package org.agoncal.sample.jmh;	
import java.util.Random;	
/**	
 * Created by emacsist on 2017/6/15.	
 */	
public abstract class StringKitAbs {	
    // 生成随机数字和字母,	
    public String getStringRandom(int length) {	
        String val = "";	
        Random random = new Random();	
        // 参数length，表示生成几位随机数	
        for (int i = 0; i < length; i++) {	
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";	
            // 输出字母还是数字	
            if ("char".equalsIgnoreCase(charOrNum)) {	
                // 输出是大写字母还是小写字母	
                // int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;	
                val += (char) (random.nextInt(26) + 97);	
            } else if ("num".equalsIgnoreCase(charOrNum)) {	
                val += String.valueOf(random.nextInt(10));	
            }	
        }	
        return val;	
    }	
}

有 final 修饰

package org.agoncal.sample.jmh;	
import java.util.Random;	
/**	
 * Created by emacsist on 2017/6/15.	
 */	
public abstract class StringKitAbsFinal {	
    // 生成随机数字和字母,	
    public final String getStringRandomFinal(int length) {	
        String val = "";	
        Random random = new Random();	
        // 参数length，表示生成几位随机数	
        for (int i = 0; i < length; i++) {	
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";	
            // 输出字母还是数字	
            if ("char".equalsIgnoreCase(charOrNum)) {	
                // 输出是大写字母还是小写字母	
                // int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;	
                val += (char) (random.nextInt(26) + 97);	
            } else if ("num".equalsIgnoreCase(charOrNum)) {	
                val += String.valueOf(random.nextInt(10));	
            }	
        }	
        return val;	
    }	
}

测试代码

写一个类来继承上面的抽象类，以此来测试在继承中 final 有否对多态中的影响

package org.agoncal.sample.jmh;	
/**	
 * Created by emacsist on 2017/6/15.	
 */	
public class StringKitFinal extends StringKitAbsFinal {	
}

package org.agoncal.sample.jmh;	
/**	
 * Created by emacsist on 2017/6/15.	
 */	
public class StringKit extends StringKitAbs {	
}

然后在基准测试中:

@Benchmark	
    public void benchmark() {	
        new StringKit().getStringRandom(32);	
    }	
    @Benchmark	
    public void benchmarkFinal() {	
        new StringKitFinal().getStringRandomFinal(32);	
    }

测试结果

非 final 结果
# JMH version: 1.19	
# VM version: JDK 1.8.0_92, VM 25.92-b14	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmark	
中间忽略了预热及测试过程	
Result "org.agoncal.sample.jmh.Main.benchmark":	
  213462.677 ±(99.9%) 8670.164 ops/s [Average]	
  (min, avg, max) = (135751.428, 213462.677, 264182.887), stdev = 36710.017	
  CI (99.9%): [204792.513, 222132.841] (assumes normal distribution)

有 final 结果

# JMH version: 1.19	
# VM version: JDK 1.8.0_92, VM 25.92-b14	
# VM invoker: /srv/jdk1.8.0_92/jre/bin/java	
# VM options: <none>	
# Warmup: 20 iterations, 1 s each	
# Measurement: 20 iterations, 1 s each	
# Timeout: 10 min per iteration	
# Threads: 1 thread, will synchronize iterations	
# Benchmark mode: Throughput, ops/time	
# Benchmark: org.agoncal.sample.jmh.Main.benchmarkFinal	
中间忽略了预热及测试过程	
Result "org.agoncal.sample.jmh.Main.benchmarkFinal":	
  213684.585 ±(99.9%) 8571.512 ops/s [Average]	
  (min, avg, max) = (133472.162, 213684.585, 267742.236), stdev = 36292.318	
  CI (99.9%): [205113.073, 222256.097] (assumes normal distribution)
总对比
# Run complete. Total time: 00:13:35	
Benchmark             Mode  Cnt       Score      Error  Units	
Main.benchmark       thrpt  200  213462.677 ± 8670.164  ops/s	
Main.benchmarkFinal  thrpt  200  213684.585 ± 8571.512  ops/s

它们字节码的区别

[12:12:19] emacsist:classes $ diff /tmp/StringKit.log /tmp/StringKitFinal.log	
1,5c1,5	
< Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKit.class	
<   Last modified 2017-6-16; size 317 bytes	
<   MD5 checksum 7f9b024adc7f39345215e3e8490cafe4	
<   Compiled from "StringKit.java"	
< public class org.agoncal.sample.jmh.StringKit extends org.agoncal.sample.jmh.StringKitAbs	
---	
> Classfile /Users/emacsist/Documents/idea/logging/target/classes/org/agoncal/sample/jmh/StringKitFinal.class	
>   Last modified 2017-6-16; size 337 bytes	
>   MD5 checksum f54eadc79a90675d97e95f766ef88a87	
>   Compiled from "StringKitFinal.java"	
> public class org.agoncal.sample.jmh.StringKitFinal extends org.agoncal.sample.jmh.StringKitAbsFinal	
10,12c10,12	
<    #1 = Methodref          #3.#13         // org/agoncal/sample/jmh/StringKitAbs."<init>":()V	
<    #2 = Class              #14            // org/agoncal/sample/jmh/StringKit	
<    #3 = Class              #15            // org/agoncal/sample/jmh/StringKitAbs	
---	
>    #1 = Methodref          #3.#13         // org/agoncal/sample/jmh/StringKitAbsFinal."<init>":()V	
>    #2 = Class              #14            // org/agoncal/sample/jmh/StringKitFinal	
>    #3 = Class              #15            // org/agoncal/sample/jmh/StringKitAbsFinal	
19c19	
<   #10 = Utf8               Lorg/agoncal/sample/jmh/StringKit;	
---	
>   #10 = Utf8               Lorg/agoncal/sample/jmh/StringKitFinal;	
21c21	
<   #12 = Utf8               StringKit.java	
---	
>   #12 = Utf8               StringKitFinal.java	
23,24c23,24	
<   #14 = Utf8               org/agoncal/sample/jmh/StringKit	
<   #15 = Utf8               org/agoncal/sample/jmh/StringKitAbs	
---	
>   #14 = Utf8               org/agoncal/sample/jmh/StringKitFinal	
>   #15 = Utf8               org/agoncal/sample/jmh/StringKitAbsFinal	
26c26	
<   public org.agoncal.sample.jmh.StringKit();	
---	
>   public org.agoncal.sample.jmh.StringKitFinal();	
32c32	
<          1: invokespecial #1                  // Method org/agoncal/sample/jmh/StringKitAbs."<init>":()V	
---	
>          1: invokespecial #1                  // Method org/agoncal/sample/jmh/StringKitAbsFinal."<init>":()V	
38c38	
<             0       5     0  this   Lorg/agoncal/sample/jmh/StringKit;	
---	
>             0       5     0  this   Lorg/agoncal/sample/jmh/StringKitFinal;	
40c40	
< SourceFile: "StringKit.java"	
---	
> SourceFile: "StringKitFinal.java"

可以看到，除了它们的方法签名和方法名字不同之外其他的都是一样的，包括JVM调用指令也完全是一样的。

结论

可以看到它们几乎是一样的。

总结

基于上面的基准测试结论，我认为滥用或刻意为了所谓的提升性能，而去为每一个方法尽可能添加 final 的关键字是不可取的。使用 final ，更多的应该是根据Java对 final 的语义来定义，而不是只想着为了提升性能（而且这影响可以忽略不计）而刻意用 final.

使用 final 的情况:

final 变量: 表示只读（只初始化一次，但可多次读取） final 方法：表示子类不可以重写。（网上认为 final 比非 final 快，就是认为它是在编译的时候已经静态绑定了，不需要在运行时再动态绑定。这个可能以前的JVM上是正确的，但在现代的JVM上，这个可以认为没什么影响，至少我在基准测试里是这样子） final 类：它们不能被继承，而且final类的方法，默认也是 final 的。

关于这个 final 的性能问题，我也Google了下，发现 stackoverflow 上，也有类似的问题：

参考资料

https://www.javazhiyin.com/go?url=https://stackoverflow.com/questions/4279420/does-use-of-final-keyword-in-java-improve-the-performance

End

扩展阅读

淘宝服务端高并发分布式架构演进之路

Java中关于try、catch、finally中的细节分析

7大绝招帮你轻轻松松提升MySQL性能

Spring注解@Resource和@Autowired区别对比

为什么说Redis是单线程的？

作者：emacsist

来源：https://emacsist.github.io/

640?wx_fmt=jpeg

java面试笔试
关注
java final class 性能_深入理解 Java 中的 final 关键字
weixin_35747627的博客
02-16 1902
final 是Java 中重要关键字之一，可以应用于类、方法以及变量上。这篇文章中将讲解什么是 final 关键字？将变量、方法和类声明为 final 代表了什么？使用 final 的好处是什么？final 关键字是什么？final 在 Java 中是一个保留的关键字，可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作 final，你将不能改变这个引用了，编译器会检查代码，如果试图将变量再...
Java中final方法比非final性能更好?
KHOST的博客
01-09 578
无继承 有 static 修饰 static final   // 生成随机数字和字母,    public static final String getStringRandomFinal(int length) {        String val = "";        Random random = new Random();  ...
java 代码编写细节-提升性能
最新发布
weixin_42710740的博客
09-03 641
根据提供的数据，getter/setter的性能已经接近直接属性访问，大约慢50%，这意味着在大多数情况下，没有必要担心getter/setter的性能而采用直接属性访问‌1。在Java中，过度的封装可能会导致一些潜在的问题，如增加了系统的复杂性、可能降低了系统的性能、可能降低了代码的可读性和可维护性。可能降低了系统的性能：在Java中，访问对象的私有属性需要通过getter和setter方法，这可能会导致一定的性能损失。适度封装：在保证代码可读性和可维护性的前提下，适当的封装是必要的。
final 修饰符能提升 Java 程序的性能吗
关注移动端、Web、微信小程序等大前端领域
01-30 4711
有的文章该问题持肯定答案，甚至说能提升 50%，并将其作为提升程序性能的建议之一；而有的文章认为这是没有必要的，因为 JVM 会对这方面做优化，所以这么做是多此一举。今天特地做了个对比试验，一探究竟。
final性能与设计
duo_shine的博客
11-08 225
前言： 小知识点 出自《on java 8》-读后感 前期绑定 将一个方法的调用和主体关联起来称为绑定，若绑定发生在程序运行前，则为前期绑定，此工作交由编译期和链接器完成，例如在 C 语言中就只有前期绑定这一种方法调用。 后期绑定 后期绑定也称为动态绑定或运行时绑定，意味着在程序运行时根据对象的类型进行绑定，在运行时需要判断对象的类型，这种机制称为方法调用机制，java中除了static方法和fi...
Java代码优化 Java final 修饰类或者方法能提高性能？还50%？老铁，你试了吗？
请叫我大师兄
06-20 2195
最近不是一直在搞优化吗，为的就是提高项目的处理能力，提高吞吐量。然后就各种搜呀，各种JProfiler测试。看看代码有啥可优化的。总能看到一个观点。 final修饰类或者方法，能是性能提高50%。 不止一次，见到这个观点。这个是真的吗？ 我来测试一下 1，先看下加final的方法和不加的差别 看不出来50%在哪里。 使用的测试代码： main方法 package com....
java中的final关键字详解及实例
08-31
在Java编程语言中，`final`关键字是一个非常重要的概念，它具有多种用途，可以用于修饰类、方法和变量。下面将详细介绍`final`关键字在不同情况下的应用和含义。 1. **final修饰类中的属性或变量** 当`final`...
简单谈谈java中final,finally,finalize的区别
09-02
Java中的`final`、`finally`和`finalize`都是关键字，但它们的作用和用途各不相同，对于初学者来说，理解这些概念可能会有些困难。让我们逐一解析它们。 **final** `final`是一个修饰符，主要用于以下几个方面： ...
Java关键字final、static使用总结
08-30
Java中的final和static是两个非常重要的关键字，它们在编程中有着特定的作用和用途。 首先，final关键字用于声明不可变的对象、方法或类。当我们说一个东西是final时，意味着它不能被修改或重写。 1. **final类**...
浅析Java中的final关键字Java开发Java经验技
12-03
本篇文章将深入探讨`final`关键字在Java中的使用和重要性，帮助开发者更好地理解和应用这一关键特性。 首先，`final`关键字用于声明变量。当一个变量被声明为`final`时，它的值一旦被初始化，就不能再改变。这在...
学习Java的static与final关键字
08-27
Java static与final关键字详解 Java 中的 static 和 final 关键字是...static 和 final 关键字是 Java 中两个重要的概念，分别用于修饰成员变量、方法和类，了解其知识点和使用场景可以帮助我们更好地编写 Java 程序。
Final关键字的使用技巧及其性能优势
墨辰JC的博客
05-05 956
本文介绍了final关键字的基本用法和使用技巧，以及final关键字在提高程序性能方面的优势。使用final关键字可以提高程序的稳定性和可靠性，同时还能提高程序的性能。但是需要注意，在过度使用final关键字时需要权衡代码的可读性和性能开销。
详解java关键字final(爆肝整理，建议收藏)
wwwwwww31311的博客
01-26 4397
一、final 1、fianl可以修饰的内容 ①修饰变量 如果是基本数据类型(int,double,char)变量那么表示这个变量是不可变的，即表示一个常量，通常是大写 如果是引用类型(String,Date,Animal,Person)的变量那么表示这个引用只能指向初始化时指向的那个对象，不能在执行别的对象，但这个对象的 fianl修饰的变量一定要有初始化的值且只能初始化一次，否则会报错(还是编译时错误) ②修饰类，表示这个类是最终类，是不可被继承的。abstract与fianl是不能修饰同一个类的
class声明为final的好处
热门推荐
xyzroundo的专栏
03-15 2万+
来源：https://zhidao.baidu.com/question/397935417.htmlfinal class怎么调用亲，涉及到的知识点如下：1.final修饰类 不能被继承，也没有子类。【使用环境】：1.不是专门为继承而设计的类，类的本身方法之间有复杂的调用关系。假如随意创建这些类的子类，子类可能会错误的修改父类的实现细节2.出于安全原因，类的实现细节不允许有任何改动3.在创建对象...
在Java中使用final关键字可以提高性能吗？
asdfgh0077的博客
06-20 1252
In Java we see lots of places where the final keyword can be used but its use is uncommon. 在Java中，我
Java -final
yyj的博客之旅
05-16 226
本篇博客仅供博主一人学习使用，内容从书中总结而来，如有内容雷同纯属偶然。 final关键字的可以修饰类成员变量和方法中的局部变量。 final的意思就是最终，所以在java中就有只能定义一次或者是不可修改的意思。 final修饰类 final类不能被继承 使用final来修饰的类叫作final类。final类通常功能是完整的，它们不能被继承。Java中有许多类是final的，譬如String, Interger以及其他包装类。 在开发过程中final主和static一起来修饰工具类，使工具类开始就初始化好了
Java中使用final关键字真的能提高性能吗？
Learning
03-09 2549
  使用final关键字真的能提高性能吗？   首先这里有一篇文章： http://www.javamex.com/tutorials/java_final_performance.shtml    在这篇文章中，作者Neil Coffey说到了下面一些内容： But to the best of my knowledge, there are no class/method...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值