据我所知,每次输入字符串文字时"",字符串池中都会引用相同的String对象.
但是为什么String API不包含a public static final String Empty = "";,所以我可以使用引用String.Empty？
它至少可以节省编译时间,因为编译器会知道引用现有的String,而不必检查它是否已经被创建以供重用,对吧？我个人认为,在许多情况下,字符串文字的扩散,尤其是小字符串,是一种"代码味道".
那么,没有String.Empty背后有一个大设计理由,还是语言创作者根本没有分享我的观点？
以下代码创建了多少个String对象？
String x = new String("xyz");
String y = "abc";
x = x + y;
我访问过许多网站,其中一些人说这行代码创建了3个对象,有些人说它创建了4个.我只是想知道在执行这行代码后创建了多少个对象.
Java中的以下两个初始化之间有什么区别？
String a = new String();String b = new String("");我真的很困惑字符串实习在Java中是如何工作的.我写的时候:
String a = "ABC";
String b = "ABC";
if (a==b)
System.out.println("Equal");
编译器时编译器是否将字符串文字"ABC"存储到字符串常量池中？
这听起来不合逻辑,因为我认为字符串常量池是由JVM在运行时创建的,如果它在编译时完成,我不知道如何这样做,因为Java编译器甚至没有调用JVM.
如果它不是在编译时完成并且它是在运行时完成的,那么为什么以下返回false(取自此答案)？
// But .substring() is invoked at runtime, generating distinct objects
"test" == "!test".substring(1) // --> false
如果它是在运行时完成的,为什么JVM不能确定它们是相同的字符串？
我真的很困惑字符串实习如何在Java中工作以及Java字符串池的存储位置.
代码如下:
String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
String s3 = new String("1")+new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);
上面代码的输出是:
false
true
我知道s并且s2是不同的对象,因此结果的计算结果为false,但第二个结果的计算结果为true.有人能告诉我区别吗？
class StringTesting {
public static void main(String args[])
{
String str = "abcd";
String str1 = new String("abcd");
String str2 = str.substring(0,2);
String str3 = str.substring(0,2);
String str4 = str.substring(0,str.length());
String str5 = str1.substring(0,2);
String str6 = str1.substring(0,2);
String str7 = str1.substring(0,str1.length());
System.out.println(str2 == str3);
System.out.println(str == str4);
System.out.println(str5 == str6);
System.out.println(str1 == str7);
}
}
这是我在java 1.6.0_27上得到的输出:
false
true
false
true
有人可以解释输出.我知道Java区分存储在堆中的String和存储在String"common pool"中的String(可以是interned).在内部,他们的表现如何不同.它是如何改变子串算法的.请在适当的地方引用书籍/文章/博客等.
对于Java 1.6版,输出是false true,但是对于版本1.8,输出更改为true true.
有人可以解释为什么会这样吗？
Intern方法用于引用堆中创建的对象的相应字符串常量池,如果该对象不存在,则它将创建String常量池.如果我的理解是错误的,请纠正我.
public class Intern_String2 {
public static void main(String[] args) {
String s1 = new String("durga"); //object created in heap
String s2 = s1.concat("software");
//object durga software created in heap at runtime
String s3 = s2.intern();
// create durga software object in string constant pool as none exist.
System.out.println(s2==s3);//should be false but print true in 1.8 version.
String s4 = "durgasoftware";
System.out.println(s3==s4);//prints true in both version..
}
}
String a = "abc";
String b = a.substring(1);
b.intern();
String c = "bc";
System.out.println(b == c);
问题可能是愚蠢的,因为实习生在这里没有主要用法,我仍然对这个事实感到困惑,为什么会有b == c结果true.
什么时候
String b = a.substring(1)
执行,String b对象的引用"bc"
是否在String Constant池中b.intern创建文字"bc",即使它确实如此,怎么会b==c产生true？
当我尝试用Java执行代码时,它给了我2个不同的输出
String txt1="Hello";
String txt2="Hello";
System.out.println((boolean)txt1==txt2);
String txt1=new String("Hello");
String txt2=new String("Hello");
System.out.println((boolean)txt1==txt2);
String在以下代码段中创建了多少个不同的对象实例？
String s1 = new String("hello");
String s2 = "GoodBye";
String s3 = s1;
我不确定这里的所有推理.
通过使用new从String类创建实例的关键字,我猜这必须是一个对象.但是,我很困惑,是String在new现在考虑了一个方法,因为它有()然后它调用String文字"你好"吗？
String s2 = "Goodbye";
我认为这是一个字符串文字,因为字符串实际上是对象,所以即使字符串文字被认为是对象.不是100%确定是否属实.
String s3 = s1;只是回到s1.因此,它并不明显.
所以我的答案是2个不同的对象.
请解释我是对还是错.
因此,当我们比较对象时,我们使用equals()方法,或者在if语句中使用类似的东西.如果我们有以下代码
String a = "foo";
String b = "foo";
return a==b
因为a和b引用不同的对象,我们会将错误返回给我们.另一方面,
String a = null;
return a == null
我们会成真的.这是为什么？