【问题标题】:What are the differences of explicit and implicit instantiating String class in javajava中显式和隐式实例化String类有什么区别
【发布时间】:2013-05-02 15:44:16
【问题描述】:

有人告诉我,像这样创建 String 实例

String s = new String("Don't do this"); // explicit

有一个性能问题,因为它为双引号短语“不要这样做”创建了两个字符串实例,一个为 new String() 构造函数创建了一个实例!

今天我有时间自己测试一下,我创建了两个类:

public class String1 {
public static void main(String[] args) {
    String s = new String("Hello");
    System.out.println(s);
}
}

public class String2 {
public static void main(String[] args) {
    String s = "Hello";
    System.out.println(s);
}
}

这是javap的输出:

C:\jav>javap String1
Compiled from "String1.java"
public class String1 extends java.lang.Object{
    public String1();
    public static void main(java.lang.String[]);
}

C:\jav>javap String2
Compiled from "String2.java"
public class String2 extends java.lang.Object{
    public String2();
    public static void main(java.lang.String[]);
}

似乎它们是相同的,但是带有 -c 标志的输出是不同的。

C:\jav>javap -c String1
Compiled from "String1.java"
public class String1 extends java.lang.Object{
public String1();
  Code:
  0:   aload_0
  1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
  4:   return

public static void main(java.lang.String[]);
  Code:
  0:   new     #2; //class java/lang/String
  3:   dup
  4:   ldc     #3; //String Hello
  6:   invokespecial   #4; //Method java/lang/String."<init>":(Ljava/lang/String;)V
  9:   astore_1
  10:  getstatic       #5; //Field java/lang/System.out:Ljava/io/PrintStream;
  13:  aload_1
  14:  invokevirtual   #6; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
  17:  return

}


C:\jav>javap -c String2
Compiled from "String2.java"
public class String2 extends java.lang.Object{
public String2();
  Code:
  0:   aload_0
  1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
  4:   return

public static void main(java.lang.String[]);
  Code:
  0:   ldc     #2; //String Hello
  2:   astore_1
  3:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
  6:   aload_1
  7:   invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
  10:  return

}

所以这是我的问题:) 首先什么是“ldc”、astore_1 等?有没有描述这些的文件? 二是javac真的分不清这两句话是否相等??

【问题讨论】:

  • 您可以通过查看Java Virtual Machine specification 了解这些含义。
  • 重新new String() 操作,它完全按照您的指示进行操作。不过,该操作是所有 Java 构造函数中最快的,因为它“共享”原始字符串的字符数组。 (并不是说这样做有任何意义,除非在一些特殊情况下。)
  • 显式构造 String 会创建另一个对象,该对象仅共享初始化值的实际字符串内容(char 数组)。所以你有一个额外对象的开销,

标签: java performance javac bytecode javap


【解决方案1】:

Wikipedia has a very convenient summary of all the possible Java Bytecode instructions。另外,要获得全貌,最好使用javap -v,查看文件的全部内容,包括常量池:

Classfile /.../String1.class
  Last modified 02/05/2013; size 458 bytes
  MD5 checksum e3c355bf648c7441784ffc6b9765ba4d
  Compiled from "String1.java"
public class String1
  SourceFile: "String1.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#17         //  java/lang/Object."<init>":()V
   #2 = Class              #18            //  java/lang/String
   #3 = String             #19            //  Hello
   #4 = Methodref          #2.#20         //  java/lang/String."<init>":(Ljava/l
ang/String;)V
   #5 = Fieldref           #21.#22        //  java/lang/System.out:Ljava/io/Prin
tStream;
   #6 = Methodref          #23.#24        //  java/io/PrintStream.println:(Ljava
/lang/String;)V
   #7 = Class              #25            //  String1
   #8 = Class              #26            //  java/lang/Object
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Utf8               LineNumberTable
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               SourceFile
  #16 = Utf8               String1.java
  #17 = NameAndType        #9:#10         //  "<init>":()V
  #18 = Utf8               java/lang/String
  #19 = Utf8               Hello
  #20 = NameAndType        #9:#27         //  "<init>":(Ljava/lang/String;)V
  #21 = Class              #28            //  java/lang/System
  #22 = NameAndType        #29:#30        //  out:Ljava/io/PrintStream;
  #23 = Class              #31            //  java/io/PrintStream
  #24 = NameAndType        #32:#27        //  println:(Ljava/lang/String;)V
  #25 = Utf8               String1
  #26 = Utf8               java/lang/Object
  #27 = Utf8               (Ljava/lang/String;)V
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
{
  public String1();
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>
":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=1
         0: new           #2                  // class java/lang/String
         3: dup
         4: ldc           #3                  // String Hello
         6: invokespecial #4                  // Method java/lang/String."<init>
":(Ljava/lang/String;)V
         9: astore_1
        10: getstatic     #5                  // Field java/lang/System.out:Ljav
a/io/PrintStream;
        13: aload_1
        14: invokevirtual #6                  // Method java/io/PrintStream.prin
tln:(Ljava/lang/String;)V
        17: return
      LineNumberTable:
        line 3: 0
        line 4: 10
        line 5: 17
}

现在很清楚ldc 从哪里加载常量了。

关于为什么 javac 不关心这些优化的问题 - 这主要是因为几乎在 Java 上完成的整个优化都推迟到运行时,运行不同的编译器:JIT 编译器,它将 Java 字节码编译为本机机器码. javac 确实在优化“常见”情况方面做了一些努力,但与抖动的激进程度相去甚远。

【讨论】:

    【解决方案2】:

    ldc, astore_n, ... 是字节码指令。您可以在Wikipedia 上找到它们的列表,并通过阅读JVM specification 来获得更深入的信息。

    ldc 将一个常量(这里是一个字符串)压入堆栈以获取进一步的指令。 astore_1 将堆栈顶部的值存储到局部变量#1 中(局部变量#0 是方法的参数)。因此,在您的第二个示例中,它从常量加载 "Hello" 并将其存储在局部变量 #1 中。

    您的第一个实现表明创建了String 的新实例,然后将其存储在局部变量#1 中。因此,它的效率低于您的第二个 sn-p 代码。此外,您无法在第一个实现中使用== 比较两个字符串,因为它不是同一个实例,并且新字符串没有被保留。

    【讨论】:

      【解决方案3】:

      我认为这回答了您的主要问题,但不确定 ldc Difference between string object and string literal 这里的要点是文字可以被实习。当然它可以确定它们是等价的,但这就是 equals 方法的用途,== 是测试对象相等性,在第一种情况下,java 需要将它们实例化为单独的对象。

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2011-03-04
        • 2018-09-05
        • 2012-08-11
        • 2012-08-04
        • 1970-01-01
        相关资源
        最近更新 更多