字符串对象和字符串文字之间的区别

Question

有什么区别

String str = new String("abc");

和

String str = "abc";

Answer 1

当您使用字符串文字时,字符串可以被实现,但是当您使用时,您将new String("...")获得一个新的字符串对象.

在此示例中,两个字符串文字都引用相同的对象:

String a = "abc"; 
String b = "abc";
System.out.println(a == b);  // true

在这里,创建了两个不同的对象,它们具有不同的引用:

String c = new String("abc");
String d = new String("abc");
System.out.println(c == d);  // false

通常,应尽可能使用字符串文字表示法.它更容易阅读,它为编译器提供了优化代码的机会.

Answer 2

一个文本字符串是Java语言的概念.这是一个字符串文字:

"a String literal"

甲字符串对象是的单个实例java.lang.String的类.

String s1 = "abcde";
String s2 = new String("abcde");
String s3 = "abcde";

一切都有效,但略有不同.s1将引用一个interned String对象.这意味着,字符序列"abcde"将存储在中心位置,并且每当"abcde"再次使用相同的文字时,JVM将不会创建新的String对象,而是使用缓存的 String 的引用.

s2保证是一个新的String对象,所以在这种情况下我们有:

s1 == s2 // is false
s1 == s3 // is true
s1.equals(s2) // is true

Answer 3

长的答案,请点击这里,让我给你的短之一.

当你这样做:

String str = "abc";

您正在调用Stringintern()上的方法.此方法引用了一个内部池的对象.如果您调用的String 已驻留在池中,则会为其分配对该引用的引用.如果没有,则将新的放置在池中,然后为其分配对它的引用.Stringintern()StringstrStringstr

给出以下代码:

String str = "abc";
String str2 = "abc";
boolean identity = str == str2;

当您通过执行检查对象标识时==(您实际上是在询问:这两个引用是否指向同一个对象？),您得到了true.

但是,你没有需要到intern() Strings.您可以Object通过执行以下操作强制在Heap上创建新的:

String str = new String("abc");
String str2 = new String("abc");
boolean identity = str == str2;

在这个例子中,str并且str2是对不同的引用Objects,它们都没有被实习,所以当你Object使用时测试身份==,你就会得到false.

在良好的编码实践两方面:千万不能使用==检查字符串是否相等,用.equals()代替.

Answer 4

由于字符串是不可变的,当你这样做时:

String a = "xyz"

在创建字符串时,如果已经存在字符串值"xyz",JVM将在字符串池中搜索,如果是,'a'则只是该字符串的引用,并且不会创建新的String对象.

但如果你说:

String a = new String("xyz")

您强制JVM创建新String引用,即使"xyz"它在池中.

欲了解更多信息,请阅读此.

Answer 5

"abc" 是一个文字字符串.

在Java中,这些文字字符串在内部汇集,并且"abc"在代码中声明了字符串文字的地方使用相同的String实例.因此它们"abc" == "abc"将始终为真,因为它们都是相同的String实例.

使用该String.intern()方法,您可以将任何您喜欢的字符串添加到内部池化的字符串中,这些字符串将保留在内存中,直到java退出.

另一方面,using new String("abc")将在内存中创建一个新的字符串对象,逻辑上与"abc"文字相同. "abc" == new String("abc")永远都是假的,因为尽管它们在逻辑上是相等的,但它们指的是不同的实例.

围绕字符串文字包装String构造函数是没有价值的,它只是不必要地使用了比它需要的更多的内存.

Answer 6

String是Java中与其他编程语言不同的类.因此对于每个类,对象声明和初始化是

String st1 = new String();

要么

String st2 = new String("Hello"); 
String st3 = new String("Hello");

这里st1,st2而且st3是不同的对象.

那是:

st1 == st2 // false
st1 == st3 // false
st2 == st3 // false

因为st1,st2,st3正在引用3个不同的对象,并且==检查在存储器位置中的平等,因此结果.

但:

st1.equals(st2) // false
st2.equals(st3) // true

在此.equals()方法检查的内容,内容st1 = "",st2 = "hello"和st3 = "hello".因此结果.

并且在String声明的情况下

String st = "hello";

这里调用类的intern()方法String,并检查是否"hello"在实习池中,如果没有,则将其添加到实习池中,如果实际池中存在"hello",st则将指向现有池的内存"hello".

所以在以下情况下:

String st3 = "hello";
String st4 = "hello"; 

这里:

st3 == st4 // true

因为st3并st4指向相同的内存地址.

也:

st3.equals(st4);  // true as usual

Answer 7

在第一种情况下,创建了两个对象.

在第二种情况下,它只是一个.

虽然两种方式str都是指"abc".

Answer 8

一些拆卸总是很有趣......

$ cat Test.java 
public class Test {
    public static void main(String... args) {
        String abc = "abc";
        String def = new String("def");
    }
}

$ javap -c -v Test
Compiled from "Test.java"
public class Test extends java.lang.Object
  SourceFile: "Test.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method  #7.#16;  //  java/lang/Object."<init>":()V
const #2 = String  #17;     //  abc
const #3 = class   #18;     //  java/lang/String
const #4 = String  #19;     //  def
const #5 = Method  #3.#20;  //  java/lang/String."<init>":(Ljava/lang/String;)V
const #6 = class   #21;     //  Test
const #7 = class   #22;     //  java/lang/Object
const #8 = Asciz   <init>;
...

{
public Test(); ...    

public static void main(java.lang.String[]);
  Code:
   Stack=3, Locals=3, Args_size=1
    0:    ldc #2;           // Load string constant "abc"
    2:    astore_1          // Store top of stack onto local variable 1
    3:    new #3;           // class java/lang/String
    6:    dup               // duplicate top of stack
    7:    ldc #4;           // Load string constant "def"
    9:    invokespecial #5; // Invoke constructor
   12:    astore_2          // Store top of stack onto local variable 2
   13:    return
}

Answer 9

除了已经发布的答案,还可以看到关于javaranch的这篇优秀文章.