字符串在Java中是对象，那么为什么不'；我们使用'；新'；创造它们？

我们通常使用

new

关键字创建对象，如：

Object obj = new Object();

字符串是对象，但我们不使用

new

创建它们：

String str = "Hello World";

---

为什么会这样？我可以用

new

创建一个字符串吗？

这是一个快捷方式。它本来不是这样的，但Java改变了它

---

本文对此进行了简要的论述。Java规范指南也谈到了这一点。但是我在网上找不到它。

请随意使用创建一个新字符串

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

常用的表示法

s=“新字符串”

或多或少是一种方便的快捷方式-出于性能原因，应该使用它，但极少数情况除外，在这种情况下，确实需要符合等式的字符串

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

编辑

---

回应评论：这不是一个建议，只是对提问者论文的一个直接回应，我们不对字符串使用“new”关键字，这根本不是真的。希望这篇编辑（包括上面的）能澄清一点。顺便说一句，以上问题有几个好的、更好的答案。

字符串需要进行一些优化（因为缺少更好的短语）。请注意，与其他对象不同，字符串还具有运算符重载（对于+运算符）。所以这是一个非常特殊的情况。

语法糖。

String s = new String("ABC");

---

语法仍然可用。

除了前面所说的，字符串文本[即，Java中类似

“abcd”

的字符串，但不类似

新字符串（“abcd”）

]的字符串都是内部的-这意味着每次引用“abcd”，都会引用单个

字符串
实例，而不是每次都换一个新的。因此，您将有：

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

a == b; //True

但是如果你有

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

那就有可能

a == b; // False

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

内联字符串文字很好，因为它们经常被多次使用。例如，考虑（设计的）代码：

for（int i=0；i<10；i++）{
System.out.println（“下一次迭代”）；
}

如果我们没有字符串的实习，“下一次迭代”将需要实例化10次，而现在它将只实例化一次。
您仍然可以使用
新字符串（“字符串”）
，但是如果没有字符串文本，创建新字符串将更加困难。。。您必须使用字符数组或字节：-）字符串文字有一个附加属性：从任何类指向同一字符串实例的所有相同字符串文字（它们是内部的）。
字符串是Java中的“特殊”对象。Java设计人员明智地认为字符串的使用非常频繁，因此他们需要自己的语法和缓存策略。当您通过以下语句声明字符串时：

String myString = "something";

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

String myOtherString = "something";

Java非常聪明，可以确定myString和myOtherString是相同的，并将它们作为同一个对象存储在全局字符串表中。这取决于这样一个事实，即您不能修改字符串来实现这一点。这降低了所需的内存量，并且可以更快地进行比较

相反，如果你写

String myOtherString = new String("something");

Java将为您创建一个全新的对象，不同于myString对象。
在Java中，字符串是一种特殊情况，有许多规则只适用于字符串。双引号使编译器创建字符串对象。由于字符串对象是不可变的，这允许编译器对多个字符串进行内部存储，并构建更大的字符串池。两个相同的字符串常量将始终具有相同的对象引用。如果不希望出现这种情况，则可以使用新字符串（“”），这将在运行时创建字符串对象。intern（）方法过去很常见，用于根据字符串查找表检查动态创建的字符串。一旦插入字符串，对象引用将指向规范字符串实例

    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

当类加载器加载一个类时，所有的字符串常量都被添加到字符串池中。
几乎不需要新建字符串，因为文本（引号中的字符）已经是加载宿主类时创建的字符串对象。在文本和don上调用方法是完全合法的，主要区别在于文本提供的便利性。如果我们必须创建一个字符数组，并逐个字符填充，然后执行一个新字符串（字符数组），这将是一个巨大的痛苦和浪费时间。
文本池包含未使用关键字
new
创建的任何字符串

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

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

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").

希望这能消除一些疑问。：）
 因为String在java中是一个不可变的类

为什么它是不变的？
因为字符串是不可变的，所以它可以在多个线程之间共享，我们不需要在外部同步字符串操作。
As字符串也用于类加载机制。所以，若字符串是可变的，那个么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");

输出：

真的

我创建了两个独立的对象，它们都有一个字段（ref）“Name”。因此，即使在这种情况下，“Jan Peter”也是共享的，如果我了解java的交易方式
 我们通常使用字符串文字来避免创建不必要的对象。若我们使用new操作符来创建字符串对象，那个么它每次都会创建新对象

例如：

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

对于内存中的上述代码：

StringPool是使用java中的Hashmap实现的。如果我们总是用一个新的关键字来创建它，它就不会在字符串池中搜索，也不会为它创建一个新的内存，如果我们有一个me，以后可能会需要这个内存
String s1=“Hello“;
String s2=“Hello“;
String s3= new String(“Hello“);
String s4= new String(“Hello“);