3

有人告诉我，像这样创建 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真的想不通这两句话是相等的吗？？

4

3 回答 3

2

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

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

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

于 2013-05-02T16:04:26.330 回答
2

Wikipedia 对所有可能的 Java 字节码指令进行了非常方便的总结。此外，要获得全貌，最好使用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 确实为优化“常见”情况做出了一些努力，但它与抖动的激进程度相去甚远。

于 2013-05-02T16:08:15.060 回答
0

我认为这回答了您的主要问题，但不确定 ldc字符串对象和字符串文字之间的区别这里的要点是可以实习的文字。当然它可以确定它们是等价的，但这就是 equals 方法的用途，== 是测试对象相等性，在第一种情况下，java 需要将它们实例化为单独的对象。

于 2013-05-02T15:48:18.403 回答