【Java原理探索】「编译器专题」重塑认识Java编译器的执行过程(常量优化机制)!

简介: 【Java原理探索】「编译器专题」重塑认识Java编译器的执行过程(常量优化机制)!

问题概括


静态常量可以再编译器确定字面量,但常量并不一定在编译期就确定了, 也可以在运行时确定,所以Java针对某些情况制定了常量优化机制。



常量优化机制


  1. 给一个变量赋值,如果等于号的右边是常量的表达式并且没有一个变量,那么就会在编译阶段计算该表达式的结果。
  2. 然后判断该表达式的结果是否在左边类型所表示范围内。
  3. 如果在,那么就赋值成功,如果不在,那么就赋值失败。

注意如果一旦有变量参与表达式,那么就不会有编译期间的常量优化机制。


结合问题,我们就可以大致猜出,如果常量能在编译期确定就会有优化,不能的话就不存在。


下面我们来详细讲解一下这个机制,Java中的常量池常量优化机制主要是两方面



就是对于byte/short/char三种类型的常量优化机制


先贴出一张Java八大数据类型大小范围表以供参考:


image.png

以下面这个程序为例
byte b1  = 1 + 2;
System.out.println(b1);
// 输出结果 3
复制代码



运行结果解释:


1和2都是常量,Java有常量优化机制,就是可以编译时可以明显确定常量结果,所以直接把1和2的结果赋值给b1了。(和直接赋值3是一个意思)


换一种情况看看,把右边常量改成变量
byte b1  = 3;
byte b2  = 4;
byte b3 = b1 + b2;
System.out.println(b3);  // 程序报错


image.png


程序报错了,意思说类型不匹配:无法从int转换为byte


解释原因,从两个方面:


  • byte 与 byte (或者 short char ) 进行运算的时候会提升int 两个int 类型相加的结果也是int 类型
  • b1 和 b2 是两个变量,变量存储的是变化,在编译的时候无法判断里面的值,相加有可能会超出byte的取值这就是为什么一旦有变量参与表达式,那么就不会有编译期间的常量优化机制。


在这里我们试着把变量添加final改回常量,看看又有什么结果

final byte b1  = 1;
final byte b2  = 2;
byte b3 = b1 + b2;
System.out.println(b3); 
复制代码



发现程序可以正常运行,输出结果为3,所以可知常量优化机制一定是针对常量的。


接下来我们再看另外一个程序


byte b1  = 127 + 2;   
System.out.println(b4);
复制代码



程序再次报错,同样也是类型不匹配:无法从int转换为byte,这里解释一下,byte取值范围为-128~127;很明显右边表达式的结果是否在左边类型所表示范围,这个就是导致此错误出现的原因。


某些场景下,取值范围大的数据类型(int)可以直接赋值给取值范围小的(byte、shor、char),而且只能特定int赋值给byte/short/char,其他基本数据类型不行,如下图。


int num1 = 10;
final int num2 = 10;
byte var1 = num1 + 20;  // 存在变量,编译报错
byte var2 = num2 + 20; // 编译通过
复制代码


这个也是常量优化机制的一部分


所以我们这里总结一下byte/short/char三种类型的常量优化机制


  • 先判断值是否是常量, 然后再看值是否在该数据类型的取值范围内
  • 只有byte, short, char 可以使用常量优化机制,转换成int类型(这个你换成其他基本数据类型就不适应了)来个程序测试一下,下面这个就是单纯把之前的byte改成了int型,发现并不像之前报错,反而正常运行,输出结果3,所以就说明了只有byte, short, char 可以使用常量优化机制
int a = 1;
int b = 2;
int c = a + b;
System.out.println(c);
复制代码


拓展一下(易错点):


byte var = 10;
var = var + 20; // 编译报错,运算中存在变量
var += 20; // 等效于: var = (short) (var + 20); 没有走常量优化机制,而是进行了类型转换
复制代码





就是对于编译器对String类型优化(这个是重点难点)


String s1 = "abc";
String s2 = "a"+"b"+"c";
System.out.println(s1 == s2);
复制代码



  • 这个输出的结果是多少呢?有人就会认为 “a” + “b”+“c"会生成新的对象"abc”,但是这个对象和String s2 = "abc"不同,(a == b)是比较对象引用,因此不相等,结果为false。
  • 如果你是这样想的话,那恭喜你对java的String有一定了解,但是你不清楚Java的常量池常量优化机制。



这个代码正确输出结果为true!!!


那么到底为什么呢,下面就来解释一下原因:


String s2 = “a” + “b”+“c”;编译器将这个"a" + “b”+“c"作为常量表达式,在编译时进行优化,直接取表达式结果"abc”,这里没有创建新的对象,而是从JVM字符串常量池中获取之前已经存在的"abc"对象。因此a,b具有对同一个string对象的引用,两个引用相等,结果true。


意思是说先通过优化,代码简化为

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
复制代码



再基于jvm对String的处理机制的基础上,得出true的结论。


下面进一步探讨,什么样的String + 表达式会被编译器当成常量表达式?


String b = "a" + "b";
复制代码



这个String + String被正式是ok的,那么string + 基本类型呢?


String a = "a1";
String b = "a" + 1;
System.out.println((a == b));  //result = true
复制代码
String a = "atrue";
String b = "a" + true;
System.out.println((a == b));  //result = true
复制代码
String a = "a3.4";
String b = "a" + 3.4;
System.out.println((a == b));  //result = true
复制代码



可见编译器对String + 基本类型是当成常量表达式直接求值来优化的。





既然常量弄完了,我们换成变量来试试

String s1 = "ab";
String s2 = "abc";
String s3 = s1 + "c";
System.out.println(s3 == s2);
输出的结果是false
复制代码


这里我们就可以看到常量优化只是针对常量,如果有变量的话就不能被优化


运行原理


  • String s3 = s1+“c”;这一句话,是在StringBuffer缓冲区中进行创建一个StringBuffer对象,将两者相加。
  • 但是对s3进行赋值时不能够直接将缓冲区的对象地址取来而是用toString方法变成另外的堆内存,然后赋值给s3,所以,s3和s2的地址值已经不同了,所以输出false。


这里我们还可以拓展一下,把s1前面加final修饰符修改为常量看看

final String s1 = "ab";
String s2 = "abc";
String s3 = s1 + "c";
System.out.println(s2 == s3);
复制代码


输出的结果居然变成了true,看来只要是进入常量池的常量,就有可能存在常量优化机制



再往里走一点,观察下面程序


private static String getS() {
  return "b";
}
String s1 = "abc";
String s2 = "a"+getS();
System.out.println((s1 == s2));
复制代码

结果又是出人意料,竟然是false


运行原理


编译器发现s2值是要调用函数才能计算出来的,是要在运行时才能确定结果的,所以编译器就设置为运行时执行到String s3=“a” + getS();时 要重新分配内存空间,导致s2和s1是指向两个不同的内存地址,所以==比较结果为false;


看来String这个所谓的"对象",完全不可以看成一般的对象,Java对String的处理近乎于基本类型,最大限度的优化了几乎能优化的地方。





我们来举个例子总结一下上面所有内容

public static void main(String[] arge) {
        //1
        String str1 = new String("1234");
        String str2 = new String("1234");
        System.out.println("new String()==:" + (str1 == str2));
        //2
        String str3 = "1234";
        String str4 = "1234";
        System.out.println("常量字符串==:" + (str3 == str4));
        //3
        String str5 = "1234";
        String str6 = "12" + "34";
        System.out.println("常量表达式==:" + (str5 == str6));
    //4
    String str7 = "1234";
    String str8 = "12";
    String str9 = str8 + "34";
    System.out.println("字符串和变量相加的表达式==:" + (str7 == str9));
    //5
    final String val = "34";
        String str10 = "1234";
        String str11 = "12" + val;
        System.out.println("字符串和常量相加的表达式==:" + (str10 == str11));
        //6
        String str12 = "1234";
        String str13 = "12" + 34;
        System.out.println("字符串和数字相加的表达式==:" + (str12 == str13));
        //7
        String str14 = "12true";
        String str15 = "12" + true;
        System.out.println("字符串和Boolen相加表达式==:" + (str14 == str15));
        //8
        String str16 = "1234";
        String str17 = "12" + getVal();
        System.out.println("字符串和函数得来的常量相加表达式==:" + (str16 == str17));
    }
    private static String getVal()
    {
        return "34";
    }
复制代码



运行输出:

new String()==:false
常量字符串==:true
常量表达式==:true
字符串和变量相加的表达式==:false
字符串和常量相加的表达式==:true
字符串和数字相加的表达式==:true
字符串和Boolen相加表达式==:true
字符串和函数得来的常量相加表达式==:false
复制代码



代码分析:


Java中,String是引用类型;==是关系运算符,==比较两个引用类型时,判断的依据是:双方是否是指向了同一个内存地址。


  • (1)String为引用类型,str1和str2为新实例化出来的对象,分别指向不同的内存地址。而==对于引用类型判断,是判断的是引用地址,所以例子1结果为false。
  • (2)对于第二个例子,编译器编译代码时,会将”1234”当做一个常量,并保存在JVM的常量池中,然后编译String str3=”1234”;时,将常量的指针赋值给str3,在编译String str4=”1234”;时,编译器查找常量池里有没有值相同的常量,如果有就将存在的常量赋给str4,这样结果就是str3和str4都指向了常量池中的常量的地址,所以==比较结果为true;
  • (3)第三个例子,编译时编译器发现能够计算出”12”+”34”的值,它是个常量,就按照第二个例子一样处理,最终str5和str6都指向了同一个内存地址。所以==比较结果为true;
  • (4)第四个例子,常量优化只针对常量,String str9 = str8 + “34”;这一句话,str9的值在运行时才能确定结果,是在StringBuffer缓冲区中进行创建一个StringBuffer对象,将两者相加。但是对s3进行赋值时不能够直接将缓冲区的对象地址取来而是用toString方法变成另外的堆内存,然后赋值给s3,所以,s3和s2的地址值已经不同了,所以输出false。
  • (5)第五个例子、第六个例子和第七个例子,类似第三个例子,编译时编译器发现能够计算出值,就尽量计算出来,所以==比较结果为true;
  • (6)第八个例子中,编译器发现str17值是要调用函数才能计算出来的,是要在运行时才能确定结果的,所以编译器就设置为运行时执行到String str17=“12” + getVal();时 要重新分配内存空间,导致str13和str1是指向两个不同的内存地址,所以==比较结果为false;




总结一下


Java语言为字符串连接运算符(+)提供特殊支持,并为其他对象转换为字符串。 字符串连接是通过StringBuilder (或StringBuffer )类及其append方法实现的。 字符串转换是通过方法来实现toString(JDK1.8 api文档) 。(toString方法返回值是String,所以会返回一个String对象)。由于String的不可变性,对其进行操作的效率会大大降低,但对 “+”操作符,编译器对其进行了优化,往通俗来讲,如果编译时能直接得到最终字符串的结果就尽量获得最后的字符串,这样就免于中间创建对象的浪费了。


String str = "a" + "b" + "c";  // 直接等价于 str = "abc"; 
 // 这个就解释了上面为true的所有情况
复制代码



如果不能直接计算得到最终的字符串,就像上面的例子4一样,str17明显要调用函数才能计算出来的,是要在运行时才能确定结果,那肯定必须的开辟内存创建新的对象。具体就是通过黄色字体所描述的方法





目录
打赏
0
0
0
0
375
分享
相关文章
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节,提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装,以及线程池的封装。Runnable 适用于无返回值任务,Callable 支持有返回值任务。线程池(如 ExecutorService)则用于管理和复用线程,减少性能开销。示例代码展示了如何实现这些封装,使多线程编程更加高效和安全。
【JAVA】生成accessToken原理
在Java中,生成accessToken用于身份验证和授权,确保合法用户访问受保护资源。流程包括:1. 身份验证(如用户名密码、OAuth 2.0);2. 生成唯一且安全的令牌;3. 设置令牌有效期并存储;4. 客户端传递令牌,服务器验证其有效性。常见场景为OAuth 2.0协议,涉及客户端注册、用户授权、获取授权码和换取accessToken。示例代码展示了使用Apache HttpClient库模拟OAuth 2.0获取accessToken的过程。
Java中的算法优化与复杂度分析
在Java开发中,理解和优化算法的时间复杂度和空间复杂度是提升程序性能的关键。通过合理选择数据结构、避免重复计算、应用分治法等策略,可以显著提高算法效率。在实际开发中,应该根据具体需求和场景,选择合适的优化方法,从而编写出高效、可靠的代码。
56 6
|
2月前
|
探索Java NIO:究竟在哪些领域能大显身手?揭秘原理、应用场景与官方示例代码
Java NIO(New IO)自Java SE 1.4引入,提供比传统IO更高效、灵活的操作,支持非阻塞IO和选择器特性,适用于高并发、高吞吐量场景。NIO的核心概念包括通道(Channel)、缓冲区(Buffer)和选择器(Selector),能实现多路复用和异步操作。其应用场景涵盖网络通信、文件操作、进程间通信及数据库操作等。NIO的优势在于提高并发性和性能,简化编程;但学习成本较高,且与传统IO存在不兼容性。尽管如此,NIO在构建高性能框架如Netty、Mina和Jetty中仍广泛应用。
59 3
|
2月前
|
Java CAS原理和应用场景大揭秘:你掌握了吗?
CAS(Compare and Swap)是一种乐观锁机制,通过硬件指令实现原子操作,确保多线程环境下对共享变量的安全访问。它避免了传统互斥锁的性能开销和线程阻塞问题。CAS操作包含三个步骤:获取期望值、比较当前值与期望值是否相等、若相等则更新为新值。CAS广泛应用于高并发场景,如数据库事务、分布式锁、无锁数据结构等,但需注意ABA问题。Java中常用`java.util.concurrent.atomic`包下的类支持CAS操作。
88 2
Java 11 的String是如何优化存储的?
本文介绍了Java中字符串存储优化的原理和实现。通过判断字符串是否全为拉丁字符,使用`byte`代替`char`存储,以节省空间。具体实现涉及`compress`和`toBytes`方法,前者用于尝试压缩字符串,后者则按常规方式存储。代码示例展示了如何根据配置决定使用哪种存储方式。
深入理解Java异常处理机制
Java的异常处理是编程中的一块基石,它不仅保障了代码的健壮性,还提升了程序的可读性和可维护性。本文将深入浅出地探讨Java异常处理的核心概念、分类、处理策略以及最佳实践,旨在帮助读者建立正确的异常处理观念,提升编程效率和质量。
153 1
|
2月前
|
深入理解Java中的异常处理机制
本文探讨了Java编程语言中异常处理的核心概念,包括异常类型、异常捕获与抛出、以及最佳实践。通过分析常见的异常场景和处理策略,旨在帮助开发者更好地理解和运用异常处理机制,提高代码的健壮性和可维护性。文章不仅涵盖了基本的try-catch结构,还深入讨论了自定义异常的创建与使用,以及finally块的重要性和应用。此外,还将介绍一些高级技巧,如多异常捕获和嵌套异常处理,为读者提供全面的技术指导。
119 0
深入分析Java反射(八)-优化反射调用性能
Java反射的API在JavaSE1.7的时候已经基本完善,但是本文编写的时候使用的是Oracle JDK11,因为JDK11对于sun包下的源码也上传了,可以直接通过IDE查看对应的源码和进行Debug。
424 0
Java社招面试题:一个线程运行时发生异常会怎样?
大家好,我是小米。今天分享一个经典的 Java 面试题:线程运行时发生异常,程序会怎样处理?此问题考察 Java 线程和异常处理机制的理解。线程发生异常,默认会导致线程终止,但可以通过 try-catch 捕获并处理,避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理,不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制,为面试做好准备。如果你觉得有帮助,欢迎收藏、转发!
60 14

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等