试题一：
String s = new String("abc");创建了几个String对象？
涉及内容：
引用变量与对象的区别；
字符串文字"abc"是一个String对象；
文字池(pool of literal strings)和堆(heap)中的字符串对象。
1、引用变量与对象：
A aa;
这个语句声明一个类A的引用变量aa[我们常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。
2、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。
System.out.println("Hello".length());
char[] cc={'H','i'};
System.out.println(cc.length);
3、字符串对象的创建:
由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间(如比较字符串时，==比equals()快)，
在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings)中，而运行时文字池成为常量池的一部分。
文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。
我们知道，对两个引用变量，使用==判断它们的值(引用)是否相等，即指向同一个对象：
String s1 = "abc" ;
String s2 = "abc" ;
if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");
else System.out.println("trouble");
这里的输出显示s1,s2 refer to the same object，两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。
即s1,s2指向了同一个对象。
s1-------
|
|-------"abc"
|
s2-------
现在看String s = new String("abc");语句：
这里"abc"本身就是pool中的一个对象，而在执行new String()时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。
即引用s指向了两个对象。
|-------"abc"
|
s-------|
|
|-------new String()
String s1 = new String("abc") ;
String s2 = new String("abc") ;
if( s1 == s2 ){ //不会执行的语句}
这时用==判断就可知，虽然两个对象的"内容"相同(equals()判断)，但两个引用变量所持有的引用不同，
上面的代码创建了几个String Object? (三个，pool中一个，heap中2个。)
|-------new String()
|
s1------|
|
|-------"abc"
|
s2--------|
|
|-----new String()
String s1 = "abc";
String s2 = new String("abc");
上面代码创建了几个对象？
两个。pool中一个，heap中一个。
试题二：
先看看下面的代码
public String makinStrings()
{
String s = "Fred";
s = s + "47";
s = s.substring(2, 5);
s = s.toUpperCase();
return s.toString();
}
问：调用makinStrings方法会创建几个String对象呢。
答案：3个
上面的方法有五条语句：现在让我们来一条一条分析一下。
1、String s = "Fred"; 结论：创建了一个String对象
这条语句相当于String s = new String("Fred");
因此，毫无疑问，第一条语句创建了一个String对象，我想没有有疑问吧？
2、s = s + "47"; 结论：未创建String对象
这条语句也许很多人认为是创建了String对象，我一开始也是这么认为的。但是为了验证我的想法。决定
用点法术恢复这条语句的本来面目。（有很多时候，编译器总是在里面搞一些小动作，javac.exe也不例外）
现在找到这个程序所生成的.class文件（假设是Test.class)，找一个反编译工具，我推荐JAD,可以http://www.softpedia.com/progDownload/JAD-Download-85911.html下载
下载后，有一个jad.exe，将其路径放到环境变量path中（只限windows)。并在.class文件的当前路径执行如下的命令：jad Test
然后大喊一声“还我本来面目”
会在当前目录下生成一个Test.jad文件，打开它，文件内容如下：
public String makinStrings()
{
String s = "Fred";
s = (new StringBuilder(String.valueOf(s))).append("47").toString();
s = s.substring(2, 5);
s = s.toUpperCase();
return s.toString();
}
哈哈，其他的语句都没变，只有第二条变长了，虽然多了个new，但是建立的是StringBuilder对象。原来这是java编译器的优化处理。原则是能不建String对象就不建String对象。而是用StringBuilder对象加这些字符串连接起来，相当于一个字符串队列。这种方式尤其被使用在循环中，大家可以看看下面的代码:
String s = "";
for(int i=0; i < 10000000; i++)
s += "aa";
没有哪位老大认为这是建立了10000000个String对象吧。但不幸的是，上面的代码虽然没有建立10000000个String对象
但却建立了10000000个StringBuilder对象，那是为什么呢，自已用jad工具分析一下吧。
正确的写法应该是：
StringBuilder sb = new StringBuilder("");
for(int i=0; i < 10000000; i++)
sb.append(String.valueOf(i));
3、s = s.substring(2, 5); 结论：创建了一个String对象
也许有很多人一开始就认为这条语句是创建了一个String对象，那么恭喜你，这条语句确实创建了一个String对象
实际上就是substring方法创建了一个String对象。这也没什么复杂的，自已下一个JDK源代码，看看substring是如何实现的就可以知道了。我先说一下吧。先不用管substring是如何实现的，反正在substring方法返回时使用了一个new显式地建立了一个String对象不信自己看看源码。原码如下：
public String substring(int beginIndex, int endIndex) {
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
4、s = s.toUpperCase();
结论：创建了一个String对象
toUpperCase()、toLowCase()和substring()方法类似，在返回时也是使用了new建立了一个String对象。
public String toUpperCase(Locale locale) {
return new String(0, result.length, result);
}
5、return s.toString(); 结论：未创建String对象
toString方法返回的就是this，因此，它的返回值就是s。
public String toString() {
return this;
}
这道题还算比较简单，再给大家出一个更复杂一点的，也是关于String对象的创建的（只是改了一个原题）。
试题三：
public String makinStrings()
{
String s = "Fred";
s = s + "Iloveyou.".substring(1).toLowerCase();
s = s.substring(0);
s = s.substring(0,1).toUpperCase();
return s.toString();
}
先公布答案吧，上述代码也创建了3个String对象，哈哈！
为什么呢？
要想知道为什么，先得弄清楚substring、toLowerCase和toUpperCase什么时候创建String对象，什么时候不创建对象。
substring方法在截取的子字符串长度等于原字符串时，直接返回原字符串，并不创建新的String对象。
即substring(0),substring(o,字符串长度)将不会创建对象，直接返回自身。
public String substring(int beginIndex) {
return substring(beginIndex, count);
}
public String substring(int beginIndex, int endIndex) {
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
示例：
"unhappy".substring(2) returns "happy"
"unhappy".substring(0) returns "unhappy"
"smiles".substring(1, 5) returns "mile" substring从下标0开始，第0个为 s,第一个为m，返回的个数＝5-1即返回4个字符。
toLowerCase方法在字符串中根本没有需要转换的大写字母时直接返回原字符串，如"abcd".toLowerCase()直接返回abcd，并不创建新的String对象看原代码：
public String toLowerCase() {
return toLowerCase(Locale.getDefault());
}
public String toLowerCase(Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
int firstUpper;
/* Now check if there are any characters that need to be changed. */
scan: {
int c;
for (firstUpper = 0 ;firstUpper < count ;firstUpper += Character.charCount(c)) {
c = codePointAt(firstUpper);
if (c != Character.toLowerCase(c)) {
break scan;
}
}
return this;
}
char[] result = new char[count];
int resultOffset = 0;
System.arraycopy(value, offset, result, 0, firstUpper);
String lang = locale.getLanguage().intern();
boolean localeDependent = (lang == "tr" || lang == "az" || lang == "lt");
char[] lowerCharArray;
int lowerChar;
int srcChar;
int srcCount;
for (int i = firstUpper; i < count; i += srcCount) {
srcChar = codePointAt(i);
srcCount = Character.charCount(srcChar);
if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMA
lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
} else {
lowerChar = Character.toLowerCase(srcChar);
}
if ((lowerChar == Character.ERROR) ||
Character.isSupplementaryCodePoint(lowerChar)) {
if (lowerChar == Character.ERROR) {
lowerCharArray =
ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
} else {
lowerCharArray = Character.toChars(lowerChar);
}
/* Grow/Shrink result. */
int mapLen = lowerCharArray.length;
char[] result2 = new char[result.length + mapLen - srcCount];
System.arraycopy(result, 0, result2, 0,
i + resultOffset);
for (int x=0; x<mapLen; ++x) {
result2[i+resultOffset+x] = lowerCharArray[x];
}
resultOffset += (mapLen - srcCount);
result = result2;
} else {
result[i+resultOffset] = (char)lowerChar;
}
}
return new String(0, result.length, result);
}
toUpperCase方法和toLowerCase类似。"ABCD".toUpperCase()直接返回ABCD。
知道了这个，上面的代码就非常清楚了。
public String makinStrings()
{
String s = "Fred"; // 创建一个String对象
s = s + "Iloveyou.".substring(1).toLowerCase(); // substring(1)创建一个String对象，由于toLowerCase()转换的字符串是"loveyou."，没有大写字母，因此，它不创建新的String对象
s = s.substring(0); // 由于substring(0)截获的是s本身，因此，这条语句不创建新的String对象
s = s.substring(0,1).toUpperCase(); // substring(0,1)创建了一个String对象，但由于substring(0,1)的结果是"F"，为一个大写字母，因此，toUpperCase直接返回"F"本身。
return s.toString();
}
试题四、
public class TestStringBuffer {
public static void main(String[] args) {
StringBuffer a = new StringBuffer("A");
StringBuffer b = new StringBuffer("B");
operate(a,b);
System.out.println(a+","+b);
String a1 = new String("A");
String b1 = new String("B");
operateStr(a1,b1);
System.out.println(a1+","+b);
}
public static void operate(StringBuffer x,StringBuffer y){
x.append(y);
y=x;
}
public static void operateStr(String x,String y){
x+=y;
y=x;
}
}
输出结果为：
AB,B
A,B
分析：
StringBuffer只是存储字符串的缓冲区,通过x.append(y)即得到AB
但 operate(a,b);传递参数的时候只是让x也指向缓冲区,y指向另一个缓冲区，使用y=x并不能改变a,b所指向的缓冲区，所以y=x不能改变b指向的内容
所以前面输出AB,B
对String类,x+y只是创建了一个StringBuffer对象，在Buffer中加入了y的值,这样a1所指向的仍然是A,y=x一样不能改变什么，所以最后输出
结果为A，B
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
