字符串是Java中的对象，那么为什么不使用'new'来创建它们呢？

我们通常使用new关键字创建对象，例如：

Object obj = new Object();

字符串是对象，但是我们不能new用来创建它们：

String str = "Hello World";

为什么是这样？我可以用做一个琴弦new吗？

除了已经说过的内容外，还对Java中的字符串文字 [即，类似"abcd"但不喜欢的字符串new String("abcd")]进行了插值-这意味着，每次引用“ abcd”时，您都将引用一个String实例，而不是一个新实例。每一次。因此，您将拥有：

String a = "abcd";
String b = "abcd";

a == b; //True

但是如果你有

String a = new String("abcd");
String b = new String("abcd");

那么就有可能

a == b; // False

（如果有人需要提醒，请务必使用.equals()比较字符串；==测试物理相等性）。

Interning String文字很好，因为它们经常被多次使用。例如，考虑（人为）代码：

for (int i = 0; i < 10; i++) {
  System.out.println("Next iteration");
}

如果我们没有String的内部，则“下一次迭代”将需要实例化10次，而现在只需要实例化一次。

字符串是Java中的“特殊”对象。Java设计人员明智地决定使用Strings的频率很高，以至于他们需要自己的语法和缓存策略。通过以下方式声明字符串时：

String myString = "something";

myString是对String对象的引用，其值为“ something”。如果您以后声明：

String myOtherString = "something";

Java足够聪明，可以确定myString和myOtherString相同，并将它们存储在全局String表中作为同一对象。它依赖于您不能修改字符串来执行此操作的事实。这样可以减少所需的内存量，并可以使比较更快。

相反，如果您写

String myOtherString = new String("something");

Java将为您创建一个全新的对象，与myString对象不同。

String a = "abc"; // 1 Object: "abc" added to pool

String b = "abc"; // 0 Object: because it is already in the pool

String c = new String("abc"); // 1 Object

String d = new String("def"); // 1 Object + "def" is added to the Pool

String e = d.intern(); // (e==d) is "false" because e refers to the String in pool

String f = e.intern(); // (f==e) is "true" 

//Total Objects: 4 ("abc", c, d, "def").

希望这能消除一些疑问。:)

这是捷径。最初不是那样的，但是Java改变了它。

本常见问题解答简要讨论了它。Java规范指南也对此进行了讨论。但是我无法在线找到它。

字符串要经过几个优化（因为需要一个更好的短语）。请注意，String还具有运算符重载（对于+运算符），这与其他对象不同。因此，这是非常特殊的情况。

我们通常使用String文字以避免创建不必要的对象。如果我们使用new运算符创建String对象，那么它将每次都创建新对象。

例：

String s1=“Hello“;
String s2=“Hello“;
String s3= new String(“Hello“);
String s4= new String(“Hello“);

对于内存中的上述代码：

在Java中，字符串是一种特殊情况，许多规则仅适用于字符串。双引号引起编译器创建一个String对象。由于String对象是不可变的，因此允许编译器实习多个字符串，并建立更大的字符串池。两个相同的String常量将始终具有相同的对象引用。如果不希望出现这种情况，则可以使用new String（“”），这将在运行时创建String对象。intern（）方法曾经很常见，可导致根据字符串查找表检查动态创建的字符串。插入字符串后，对象引用将指向规范的String实例。

    String a = "foo";
    String b = "foo";
    System.out.println(a == b); // true
    String c = new String(a);
    System.out.println(a == c); // false
    c = c.intern();
    System.out.println(a == c); // true

当类加载器加载类时，所有String常量都将添加到String池中。

语法糖。的

String s = new String("ABC");

语法仍然可用。

您仍然可以使用new String("string")，但是在没有字符串文字的情况下创建新字符串将更加困难...您将不得不使用字符数组或字节:-)字符串文字具有一个附加属性：从任何类指向同一字符串的所有相同字符串文字实例（他们被拘留）。

几乎不需要新的字符串，因为文字（引号中的字符）已经是在加载主机类时创建的String对象。在文字上调用方法和don是完全合法的，主要区别在于文字提供的便利性。如果我们必须创建一个char数组并用char填充char，然后他们做一个新的String（char array），这将是一个很大的痛苦和浪费的例程。

随意创建一个新的字符串

String s = new String("I'm a new String");

通常的表示法s = "new String";或多或少是一种便捷的快捷方式-出于性能原因，应使用该快捷方式，但在极少数情况下，除非您确实需要符合该等式的字符串

(string1.equals(string2)) && !(string1 == string2)

编辑

对此评论作出回应：这并不是要作为建议，而只是对提问者论点的直接回应，即我们不对字符串使用'new'关键字，这根本不是事实。希望此编辑（包括上面的内容）能使您对此有所了解。顺便说一句-关于SO的上述问题有两个很好的更好的答案。

文字池包含不使用关键字创建的任何字符串new。

有一个区别：没有新引用的字符串存储在String文字池中，而有new的字符串表示它们在堆内存中。

带有new的字符串与其他任何对象一样在内存中的其他位置。

因为String是Java中的不可变类。

现在为什么它是不变的？由于String是不可变的，因此它可以在多个线程之间共享，并且我们不需要在外部同步String操作。As String也用于类加载机制。因此，如果String是可变的，则java.io.writer可能已更改为abc.xyz.mywriter

TString obj1 = new TString("Jan Peter");                
TString obj2 = new TString("Jan Peter");                    

if (obj1.Name == obj2.Name)                 
    System.out.println("True");
else                
    System.out.println("False");

输出：

真正

我创建了两个单独的对象，它们都有一个field（ref）'Name'。因此，即使在这种情况下，如果我了解java的处理方式，也可以共享“ Jan Peter”。

那么StringPool是使用Java中的Hashmap实现的。如果我们始终使用新的关键字创建它，则它不在字符串池中搜索并为其创建新的内存，如果我们正在运行占用大量内存的操作，并且正在使用new关键字创建所有会影响性能的字符串，则稍后可能需要我们的应用程序。因此建议不要使用新的关键字来创建字符串，因为只有这样，它才会进入字符串池，而该字符串池又是一个Hashmap，（保存了内存，假设我们有很多用new关键字创建的字符串）将在此处存储和如果字符串已经存在，则该字符串的引用（通常位于堆栈内存中）将返回到新创建的字符串。这样做是为了提高性能。