以字节码来分析String

最新推荐文章于 2021-08-05 17:18:38 发布
最新推荐文章于 2021-08-05 17:18:38 发布
阅读量368 收藏
点赞数
分类专栏： Java语言程序设计 JVM 文章标签： Java String 字节码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JayLoveU/article/details/70227141
版权

Java String的比较是平常开发常常遇到的坑，也是各种面试经常考察的问题，本文从Java编译后字节码的出发，来深入理解这个问题的本质，以使得我们对String有更加深入的理解。


public class TestContantPool
{

	private static String a = "1234";

	final String x = "34";

	final String y;

	public TestContantPool()
	{
		y = "34";

	}

	public void test()
	{
		String b = "1234";
		String c = "12" + "34";
		String d = new String("12345");
		final String e = "34";
		String f = "34";
		String g = "12" + e;
		String h = "12" + f;
		String i = "12" + x;
		String j = "12" + y;

		System.out.println(a == b);
		System.out.println(a == c);
		System.out.println(a != d);
		System.out.println(a == g);
		System.out.println(a != h && a == h.intern());
		System.out.println(a == i && a == i.intern());
		System.out.println(a != j && a == j.intern());

	}

	public static void main(String[] ar)
	{
		new TestContantPool().test();
	}
}

/**
true
true
true
true
true
true
true
*/

编译之后，我们来分析一下部分字节码，重点在于常量池(Constant Pool)，静态块static{}，构造方法和test()方法： 

javap -verbose TestContantPool.class 
 
 
Constant pool:
 
   #5 = Utf8               a
   #7 = Utf8               x
   #9 = String             #10            // 34
  #10 = Utf8               34
  #11 = Utf8               y
 
  #15 = String             #16            // 1234
  #16 = Utf8               1234

  #31 = Class              #32            // java/lang/String
  #32 = Utf8               java/lang/String
  #33 = String             #34            // 12345
  #34 = Utf8               12345

  #39 = Utf8               java/lang/StringBuilder
  #40 = String             #41            // 12
  #41 = Utf8               12

  #66 = Utf8               b
  #67 = Utf8               c
  #68 = Utf8               d
  #69 = Utf8               e
  #70 = Utf8               f
  #71 = Utf8               g
  #72 = Utf8               h
  #73 = Utf8               i
  #74 = Utf8               j

 
 
  final java.lang.String x;
    descriptor: Ljava/lang/String;
    flags: ACC_FINAL
    ConstantValue: String 34

  final java.lang.String y;
    descriptor: Ljava/lang/String;
    flags: ACC_FINAL

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: ldc           #15                 // String 1234
         2: putstatic     #17                 // Field a:Ljava/lang/String;
         5: return
      LineNumberTable:
        line 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature

  public bytecode.TestContantPool();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #22                 // Method java/lang/Object."<init>":()V
         4: aload_0
         5: ldc           #9                  // String 34
         7: putfield      #24                 // Field x:Ljava/lang/String;
        10: aload_0
        11: ldc           #9                  // String 34
        13: putfield      #26                 // Field y:Ljava/lang/String;
        16: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      17     0  this   Lbytecode/TestContantPool;

  public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=10, args_size=1
         0: ldc           #15                 // String 1234
         2: astore_1                                                                                                                     
         3: ldc           #15                 // String 1234
         5: astore_2
         6: new           #31                 // class java/lang/String
         9: dup
        10: ldc           #33                 // String 12345
        12: invokespecial #35                 // Method java/lang/String."<init>":(Ljava/lang/String;)V
        15: astore_3
        16: ldc           #9                  // String 34
        18: astore        4
        20: ldc           #9                  // String 34
        22: astore        5
        24: ldc           #15                 // String 1234
        26: astore        6
        28: new           #38                 // class java/lang/StringBuilder
        31: dup
        32: ldc           #40                 // String 12
        34: invokespecial #42                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
        37: aload         5
        39: invokevirtual #43                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)
        42: invokevirtual #47                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        45: astore        7
        47: ldc           #15                 // String 1234
        49: astore        8
        51: new           #38                 // class java/lang/StringBuilder
        54: dup
        55: ldc           #40                 // String 12
        57: invokespecial #42                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
        60: aload_0
        61: getfield      #26                 // Field y:Ljava/lang/String;
        64: invokevirtual #43                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)
        67: invokevirtual #47                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        70: astore        9
        
      
       235: return

1， 首先分析ConstantPool，可以看到编译之后常量池中就有了String的字面量"12"，"34"，1234"。下面代码中所有的其他String的创建都离不开常量池中的这些字面量。


2， 再看类变量a的初始化过程，根据虚拟机类加载机制可以知道，static变量和static{}代码块会在编译生成的<clinit>()方法中执行。<clinit>()是由编译器自动收集类中的所有        static变量的赋值动作和static{}代码块中的语句合并产生的，<clinit>()方法如果存在，会在实例构造函数<init>()执行。

下面两句代码是对static变量a的赋值语句，可以看出来a是从常量池中取值的：

0: ldc           #15                 // String 1234    (将int,float,String型常量值从常量池推送至栈顶)
2: putstatic     #17                 // Field a:Ljava/lang/String; (为指定的类的静态域赋值)


3，最后分析test()方法。

b和c 的赋值"1234"，都是从常量池中取值：

0: ldc           #15                 // String 1234    (将int,float,String型常量值从常量池推送至栈顶)
2: astore_1                                            (将栈顶引用型数值存入第二个本地变量)                                                                        
3: ldc           #15                 // String 1234    
5: astore_2                                            (将栈顶引用型数值存入第三个本地变量)

d的赋值"1234"，可以看到是重新调用了new了一个String对象：

6: new           #31                 // class java/lang/String (创建一个对象，并且将其引用压入栈顶)
9: dup                                                         (赋值栈顶数值，并且将复制值压入栈顶)
10: ldc           #33                 // String 12345          (将int,float,String型常量值从常量池推送至栈顶)
12: invokespecial #35                                          (调用超类构造方法，实例初始化方法)
15: astore_3                                                   (将栈顶引用型数值存入第四个本地变量)

e,f,g的赋值，都是从常量池中取值:

16: ldc           #9                  // String 34
18: astore        4
20: ldc           #9                  // String 34
22: astore        5
24: ldc           #15                 // String 1234
26: astore        6


h的赋值，使用StringBuilder new一个String（从中可以看到，String 的"+"操作是用StringBuilder实现的）：

28: new           #38                 // class java/lang/StringBuilder
31: dup
32: ldc           #40                 // String 12
34: invokespecial #42                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
37: aload         5
39: invokevirtual #43                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)
42: invokevirtual #47                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
45: astore        7

i的赋值，常量池去取：

47: ldc           #15                 // String 1234
49: astore        8

j的赋值，使用StringBuilder new一个String（从中可以看到，String 的"+"操作是用StringBuilder实现的）：

51: new           #38                 // class java/lang/StringBuilder
54: dup
55: ldc           #40                 // String 12
57: invokespecial #42                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
60: aload_0
61: getfield      #26                 // Field y:Ljava/lang/String;
64: invokevirtual #43                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)
67: invokevirtual #47                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
70: astore        9


根据以上分析，只要是从常量池中取值的，"=="比较都是true；其他的或者是new String()产生的，或者是new StringBuilder()产生的， 都是在Heap区新建对象，因此都不相等。按照这种逻辑，就能够理解String对象的比较问题了。

BitsPlayer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
语法练习：string_bits
sunbocong的博客
12-07 200
Given a string, return a new string made of every other char starting with the first, so “Hello” yields “Hlo”.string_bits(‘Hello’) → ‘Hlo’ string_bits(‘Hi’) → ‘H’ string_bits(‘Heeololeo’) → ‘Hello’ Expected Run string_bits(‘Hello’) → ‘Hlo’ ‘Hlo’ OK stri
Javassist如何操作Java 字节码
09-07
1. 简单易用：Javassist使用Java编程的方式来操作字节码，避免了ASM等库需要理解字节码指令的复杂性。 2. 高效性：相较于反射机制，Javassist在性能上有所提升，但与ASM相比，性能略低。 3. 功能丰富：Javassist提供...
CodingBat python Warmup-2
xiji333的博客
10-28 412
https://codingbat.com/python/Warmup-2A string_times def string_times(str, n): return str*n front_times def front_times(str, n): return str[:3]*n string_bits 思路：假设第一个位置为111，返回奇数位置的字符构成的字符串。 def string_bits(str): return str[::2] string_splosion
java String 之字节码解析
xiaomin1991222的专栏
11-24 400
关于java  string 的面试题有很多。。。网上的说法也有很多中。。。。  在这我解析一下string 的用法的字节码。。。。 public class C{ public C(){ } public C(String a){ this.str=a; } String str0 = "min0"; static String str = ...
Mybatis 传入String 类型的动态参数如何写？
k826240369的博客
04-03 2513
&lt;select id="queryCommunicationFieldByType" resultType="reconnoitreCommunicationField" parameterType="String"&gt; SELECT * FROM tb_reconnoitre_communication_field WHERE commun_status = 'Y'       &l...
java字节码入门（上）
xiandafu的专栏
05-20 8049
字节码 Hello world public class Helloworld { public static void main(String[] args) { System.out.println("hello,world"); } } 如果用javap查看此类结构 javap -c Helloworld.class 输出是 public...
详解python字节码
09-20
综上所述，本文深入剖析了Python字节码的组成和执行机制，通过具体的代码实例和字节码分析工具展示了字节码的工作流程，同时也指出了CPython在字符串操作上的优化策略。通过了解字节码，开发者可以更好地优化Python...
java字节码框架ASM的深入学习
08-31
它允许将对类的访问委托给另一个`ClassVisitor`实例，这样可以通过继承和重写方法来定制字节码的处理逻辑。 三、ASM使用示例 以下是一个简单的示例，展示如何使用ASM生成一个新的类的字节码： ```java import org...
JAVA字节码操作库 BCEL
06-06
2. **安全审计**：分析字节码以检测潜在的安全风险。 3. **性能监控**：在字节码层面插入监控代码，以获取更精确的性能数据。 4. **代码混淆**：通过改变字节码结构来保护源代码不被轻易逆向工程。 总之，BCEL作为...
JVM 字节码从入门到精通
02-24
接下来，为了更好地理解生成的字节码文件，我们可以使用xxd命令以十六进制的方式查看Hello.class文件的内容。通过这种方式，我们可以观察到字节码文件的结构，它包含了常量池、方法、属性等信息。 字节码文件中包含...
这次让我们从字节码文件来重新认识String,文末有两个小小面试题，一起来试一试
北
08-05 168
我想对于String这个类，没有谁对它陌生吧。可以说是无论在哪个项目中都是可以用到的。 那么反问一下你，你确定你对于String已经是真的了解了吗？你是否清楚String的内存分配？你是否清楚字节码文件中，它是如何的？你是否清楚创建String对象时，它牵扯到那几个知识点勒？一起来讨论吧。 ”八小时内谋生活，八小时外谋发展“ 共勉 地点：湖南永州市蓝山县舜河村 作者：用心笑* 重新认识String一、String基本特性1.1、基础知识1.2、大家想一想为什么会作出这样的改变勒？1.3、String不.
String a="abc"与String b=new String（"abc"）的区别
yin_xing_ye的博客
07-23 5375
先说几个概念 1、常量池 指的是在编译期确定，并被保存在已编译的字节码文件中的一些数据，它包括类、方法、接口等中的常量，存放字符串常量和基本类型常量（public static final）。 2、栈（stack） 主要保存基本数据类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（re...
String值的调用(字节码层面)
RCwukaka的博客
08-15 366
先看下简单的调用 图中的代码：package test;public class Main { String a ="asd"; public void test(){ int a = 4; } public static void main(String[] args) { String b ="asd"; }} 进行javap
深入理解 Java 虚拟机（四）~ 各种容易混淆的常量池
Chiclaim
10-13 3073
本文详细介绍了 Java 中的常量和字面量的区别，字节码中的常量池和运行时常量池的区别，最后详细介绍了字符串常量池和 String.intern 方法
C和指针课后习题（第五章）
zhouzhouzf的专栏
05-02 1609
5.1 #include #include #include int main() { char ch; while(scanf("%c",&ch)) { if (islower(ch)) { putchar(toupper(ch)); } else putchar(ch); } system("pause"); return 0; }
从class字节码从面浅析String str=“a”+”b”+”c”+”d”;语句执行生成几个String对象
max18的专栏
10-10 711
synchronized和ReentrantLock异常退出时的锁处理
BitsPlayer
04-06 2427
在JDK5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile. JDK5.0新增了ReentrantLock，作为一种可选的高级功能．ReentrantLock必须要在finally中unlock(), 否则,如果在被加锁的代码中抛出了异常,那么这个锁将会永远无法释放. synchronized就没有这样的问题, 遇到异常退出时,会释放掉已经获得的锁.
Ubuntu系统安装配置JDK
BitsPlayer
02-09 423
1，官网下载Linux版本的JDK，选择tar.gz              http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 2，下载到本地之后，解压： gunzip jdk1.8.0_112.tar.gz tar -zxvf jdk1.8.0_112.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值