Java “与”的区别是什么；“文本”；和新字符串（“文本”）？
以下两种说法的区别是什么Java “与”的区别是什么；“文本”；和新字符串（“文本”）？,java,string,Java,String,以下两种说法的区别是什么 String s = "text"; String s = new String("text"); 新字符串（“文本”） 显式地创建字符串对象的一个新的引用不同的实例字符串s=“文本”可以重用字符串常量池中的实例（如果有的话） 您很少希望使用新字符串（另一个字符串）构造函数。从API： ：初始化新创建的字符串对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。除非需要原始的显式副本，否则不需要使用此构造函数，因为字符串是不可变的 相关问题
String s = "text";
String s = new String("text");
新字符串（“文本”）
显式地创建字符串
对象的一个新的引用不同的实例<代码>字符串s=“文本”可以重用字符串常量池中的实例（如果有的话）
您很少希望使用新字符串（另一个字符串）
构造函数。从API：
：初始化新创建的字符串
对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。除非需要原始的显式副本，否则不需要使用此构造函数，因为字符串是不可变的
相关问题
所指区别是什么意思
检查以下代码段：
String s1 = "foobar";
String s2 = "foobar";
System.out.println(s1 == s2); // true
s2 = new String("foobar");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
两种引用类型上的=
是引用标识比较。两个相等的对象不一定是=
。在引用类型上使用==
通常是错误的；大多数情况下，需要使用equals
尽管如此，如果出于任何原因需要创建两个等于
而不是=
字符串，则可以使用新字符串（另一个字符串）
构造函数。然而，需要再次指出的是，这是非常奇怪的，而且很少是有意的
工具书类
相关问题
新字符串（“文本”）
显式地创建字符串
对象的一个新的引用不同的实例<代码>字符串s=“文本”可以重用字符串常量池中的实例（如果有的话）
您很少希望使用新字符串（另一个字符串）
构造函数。从API：
：初始化新创建的字符串
对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。除非需要原始的显式副本，否则不需要使用此构造函数，因为字符串是不可变的
相关问题
所指区别是什么意思
检查以下代码段：
String s1 = "foobar";
String s2 = "foobar";
System.out.println(s1 == s2); // true
s2 = new String("foobar");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
两种引用类型上的=
是引用标识比较。两个相等的对象不一定是=
。在引用类型上使用==
通常是错误的；大多数情况下，需要使用equals
尽管如此，如果出于任何原因需要创建两个等于
而不是=
字符串，则可以使用新字符串（另一个字符串）
构造函数。然而，需要再次指出的是，这是非常奇怪的，而且很少是有意的
工具书类
相关问题
在
另一个在常量池中创建一个字符串（“text”
），在正常堆空间中创建另一个字符串（s
）。两个字符串将具有相同的值，即“text”的值
如果以后未使用，s
将丢失（符合GC条件）
另一方面，字符串文本被重用。如果您在类的多个位置使用“text”
，实际上它将是一个且仅是一个字符串（即池中对同一字符串的多个引用）。在
另一个在常量池中创建一个字符串（“text”
），在正常堆空间中创建另一个字符串（s
）。两个字符串将具有相同的值，即“text”的值
如果以后未使用，s
将丢失（符合GC条件）
另一方面，字符串文本被重用。如果在类的多个位置使用“text”
，它实际上是一个且只有一个字符串（即池中对同一字符串的多个引用）。想象一下“bla”
是一个类似Strings.createString（“bla”）
（伪）的神奇工厂。工厂拥有一个以这种方式创建的所有字符串池
如果调用它，它将检查池中是否已经存在具有此值的字符串。如果为true，则返回该字符串对象，因此以这种方式获得的字符串实际上是同一个对象
如果没有，它将在内部创建一个新的字符串对象，将其保存在池中，然后返回。因此，下次查询相同的字符串值时，它将返回相同的实例
手动创建新字符串（“”）
通过绕过字符串文本池来覆盖此行为。因此，应始终使用比较字符序列而不是对象引用相等的equals（）
来检查相等性。将“bla”
视为类似Strings.createString（“bla”）
（伪）的神奇工厂。工厂拥有一个以这种方式创建的所有字符串池
如果调用它，它将检查池中是否已经存在具有此值的字符串。如果为true，则返回该字符串对象，因此以这种方式获得的字符串实际上是同一个对象
如果没有，它将在内部创建一个新的字符串对象，将其保存在池中，然后返回。因此，下次查询相同的字符串值时，它将返回相同的实例
手动创建新字符串（“”）
通过绕过字符串文本池来覆盖此行为。因此，应始终使用比较字符序列而不是对象引用相等的equals（）
检查相等性。了解差异的一种简单方法如下：-
String s ="abc";
String s1= "abc";
String s2=new String("abc");
if(s==s1){
System.out.println("s==s1 is true");
}else{
System.out.println("s==s1 is false");
}
if(s==s2){
System.out.println("s==s2 is true");
}else{
System.out.println("s==s2 is false");
}
输出为
s==s1 is true
s==s2 is false
因此，new String（）将始终创建一个新实例。理解差异的一个简单方法如下：-
String s ="abc";
String s1= "abc";
String s2=new String("abc");
if(s==s1){
System.out.println("s==s1 is true");
}else{
System.out.println("s==s1 is false");
}
if(s==s2){
System.out.println("s==s2 is true");
}else{
System.out.println("s==s2 is false");
}
输出
String str1 = new String("java5");
String str2 = "java5"
String str3 = new String(str2);
String str4 = "java5";
Pool- "java5" (1 Object)
Heap - str1 => "java5" (1 Object)
pool- str2 => "java5" (1 Object)
heap - str1 => "java5" (1 Object)
pool- str2 => "java5" (1 Object)
heap- str1 => "java5", str3 => "java5" (2 Objects)
pool - str2 => str4 => "java5" (1 Object)
heap - str1 => "java5", str3 => "java5" (2 Objects)
String str = new String("hello")
String str = "world";
package testPackage;
class Test {
public static void main(String[] args) {
String hello = "Hello", lo = "lo";
System.out.print((hello == "Hello") + " ");
System.out.print((Other.hello == hello) + " ");
System.out.print((other.Other.hello == hello) + " ");
System.out.print((hello == ("Hel"+"lo")) + " ");
System.out.print((hello == ("Hel"+lo)) + " ");
System.out.println(hello == ("Hel"+lo).intern());
}
}
class Other { static String hello = "Hello"; }
package other;
public class Other { public static String hello = "Hello"; }
true true true true false true
("a" + "b" + "c").intern() == "abc"
public class StringPool {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
String c = new String("abc");
System.out.println(a);
System.out.println(b);
System.out.println(a == c);
}
}
#2 = String #32 // abc
[...]
#32 = Utf8 abc
0: ldc #2 // String abc
2: astore_1
3: ldc #2 // String abc
5: astore_2
6: new #3 // class java/lang/String
9: dup
10: ldc #2 // String abc
12: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V
15: astore_3
16: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_1
20: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_2
27: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_1
34: aload_3
35: if_acmpne 42
38: iconst_1
39: goto 43
42: iconst_0
43: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
String obj1 = "abc";
String obj2 = "abc";
String obj1 = new String("abc");
String obj2 = new String("abc");
String str1 = "abc";
String str2 = "abc" + "def";
str1 = "xyz";
str2 = str1 + "ghi";
String string1 = "Hello";
String string2 = "Hello";
String string = new String("Hello");
import java.util.*;
class GFG {
public static void main(String[] args)
{
String siteName1 = "java.com";
String siteName2 = "java.com";
String siteName3 = new String("java.com");
String siteName4 = new String("java.com").intern();
System.out.println("siteName1:::"+Integer.toHexString(System.identityHashCode(siteName1)));
System.out.println("siteName2:::"+Integer.toHexString(System.identityHashCode(siteName2)));
System.out.println("siteName3 creation Of New Object Without Interned:::"+Integer.toHexString(System.identityHashCode(siteName3)));//must be Diffrent bcoz new Object In Heap Area
System.out.println("siteName4 creation Of New Object With Interned:::"+Integer.toHexString(System.identityHashCode(siteName4)));//must be same MemoryAddress of siteName1,siteName2 and Interned, bcoz Objects Points to String pool Now
System.out.println(siteName1 == siteName2); // true
System.out.println(siteName1 == siteName3); // false this tells about lietral vs String Objects
String siteName5 = siteName3.intern(); // Interning will not change Original Object but gives us a new Object
System.out.println("siteName5 Interned from siteName3:::"+Integer.toHexString(System.identityHashCode(siteName5)));//must be same MemoryAddress of siteName1,siteName2 and Interned, bcoz Objects Points to String pool Now
System.out.println(siteName1 == siteName3); // false this tells about Immutability
System.out.println(siteName1 == siteName5); // true After Intering both are same
System.out.println(siteName1 == siteName4); // true
System.out.println(siteName5 == siteName4); // true
}
}