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
尽管如此,如果出于任何原因需要创建两个等于
而不是=
字符串,则可以使用新字符串(另一个字符串)
构造函数。然而,需要再次指出的是,这是非常奇怪的,而且很少是有意的
工具书类
相关问题
在
另一个在常量池中创建一个字符串(“text”
),在正常堆空间中创建另一个字符串(s
)。两个字符串将具有相同的值,即“text”的值
如果以后未使用,s
将丢失(符合GC条件)
另一方面,字符串文本被重用。如果在类的多个位置使用“text”
,它实际上是一个且只有一个字符串(即池中对同一字符串的多个引用)。想象一下“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 str1 = new String("java5");
在构造函数中使用字符串文字“java5”,新的字符串值存储在字符串常量池中。
使用new操作符,在堆中创建一个新的字符串对象,值为“java5”
String str2 = "java5"
引用“str2”指向字符串常量池中已存储的值
String str3 = new String(str2);
在堆中创建一个新的字符串对象,其值与“str2”引用的值相同
引用“str4”指向字符串常量池中已存储的值
String str3 = new String(str2);
对象总数:堆-2,池-1
@Braj:我想你提到了另一种方式。如果我错了,请纠正我
逐行创建对象:
String str1 = new String("java5");
String str1=新字符串(“java5”)
字符串str2=“java5”
字符串str3=新字符串(str2)
字符串str4=“java5”
它将检查字符串常量池是否已经包含字符串“hello”?
如果存在,则不会在字符串常量池中添加条目。如果不存在,那么它将在字符串常量池中添加一个条目
将在堆内存区域中创建一个对象,并且str
引用在堆内存位置中创建的对象
如果希望str
引用字符串常量池中包含的点对象,则必须显式调用str.intern()代码>
它将检查字符串常量池是否已经包含字符串“hello”?
如果存在,则不会在字符串常量池中添加条目。如果不存在,那么它将在字符串常量池中添加一个条目
在上述两种情况下,str
引用指向常量池中存在的字符串“world”
JLS
这个概念被JLS称为“实习”
相关段落摘自:
此外,字符串文字总是引用类字符串的同一实例。这是因为字符串文字(或者更一般地说,是常量表达式(§15.28)的值的字符串)被“插入”,以便使用string.intern方法共享唯一实例
示例3.10.5-1。字符串文本
由编译单元组成的程序(§7.3):
及编制组:
package other;
public class Other { public static String hello = "Hello"; }
生成输出:
true true true true false true
JVM
:
字符串文字是对类字符串实例的引用,它源自类或接口二进制表示中的常量字符串信息结构(§4.4.3)。常量字符串信息结构给出了组成字符串文字的Unicode代码点序列
<
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
}
}