[转]通过六个题目彻底掌握String

Java中String类由于其特殊性（不变类），几乎是笔试面试中的必考题，当然有些题目其实没啥意思，不过关键是要通过题目掌握原理性的东西。下面六道题目，如果您全部做对了，且明白其所以然，那么Java中的关于String的笔试面试题应该难不到你了。也许您觉得我说的有点过了，然而彻底明白这些题目，对理解String类还是很有好处的。
写出下面各题的打印输出的结果：

1

public static void main(String[] args){
	String a = "a1";
	String b = "a" + 1;
	System.out.println(a==b);
}

2

public static void main(String[] args){
	String a = "ab";
	String bb = "b";
	String b = "a" + bb;
	System.out.println(a==b)；
}

3

public static void main(String[] args){
	String a = "ab";
	final String bb = "b";
	String b = "a" + bb;
	System.out.println(a==b);
}

4

public static void main(String[] args){
	String a = "ab";
	final String bb = getBB();
	String b = "a" + bb;
	System.out.println(a==b);
}
private static String getBB() { return "b"; }

5

private static String a = "ab";
public static void main(String[] args){
	String s1 = "a";
	String s2 = "b";
	String s = s1 + s2;
	System.out.println(s == a);
	System.out.println(s.intern() == a);
}

6

private static String a = new String("ab");
public static void main(String[] args){
	String s1 = "a";
	String s2 = "b";
	String s = s1 + s2;
	System.out.println(s == a);
	System.out.println(s.intern() == a);
	System.out.println(s.intern() == a.intern());
}

答案：

1）true

要说明一点：当两个字符串字面值连接时（相加），得到的新字符串依然是字符串字面值，保存在常量池中。

2）false

当字符串常量与String类型变量连接时，得到的新字符串不再保存在常量池中，而是在堆中新建一个String对象来存放。很明显常量池中要求的存放的是常量，有String类型变量当然不能存在常量池中了。

3）true

注意此题与上一题的区别，此处是字符串字面值与String类型常量连接，得到的新字符串依然保存在常量池中。

4）false

此题中第条语句：final String bb = getBB();其实与final String bb = new String(“b”);是一样的。也就是说return “b”会在堆中创建一个String对象保存”b”，虽然bb被定义成了final。可见并非定义为final的就保存在常量池中，很明显此处bb常量引用的String对象保存在堆中，因为getBB()得到的String已经保存在堆中了，final的String引用并不会改变String已经保存在堆中这个事实。

5）false,true

可能很多人对intern()这个函数不了解。JDK API文档中对intern()方法的描述是：

返回字符串对象的规范化表示形式。

一个初始为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。

上面字符串池即为字符串常量池。明白该题结果的原因了吧。

6）false,false,true

第五题看明白后，第六题就没什么好讲的了。

来源：http://itmian.com/2011/05/06/%e6%b7%b1%e5%85%a5%e7%90%86%e8%a7%a3javstring/

http://itmian.com/2011/05/05/six-string-interview-question-of-java/

 

 

String.intern()： 

　　再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。

String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用（常量池中字符对应的引用），如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了 

　　示例： 

　　String s0= "kvill"; 
　　String s1=new String("kvill"); 
　　String s2=new String("kvill"); 
　　System.out.println( s0==s1 ); 
　　System.out.println( "**********" ); 
　　s1.intern(); 
　　s2=s2.intern(); //把常量池中"kvill"的引用赋给s2 
　　System.out.println( s0==s1); 
　　System.out.println( s0==s1.intern() ); 
　　System.out.println( s0==s2 ); 

 

结果：

 

false

**********

false

true

true

 

 

分析：

String x = "abc";
String y = new String("abcd");

 

 现在来分析一下内存的分配情况。如图：


 
可以看出，x与y存在栈中，它们保存了相应对象的引用。第一条语句没有在堆中分配内存，而是将“abc”保存在常量池中。对于第二条语句，同样会在常量池中有一个“abcd”的字符串，当new时，会拷贝一份该字符串存放到堆中，于是y指向了堆中的那个“abcd”字符串。不知道polaris有没有讲明白。如果您明白了，那么做前面那六道题就没什么问题了。

 

-----------------------------------------------------------------------------------------------------

StringBuffer、StringBuilder 与String的equal、== 比较值的区别：

String s = "abc";

StringBuilder s1 = new StringBuilder();
StringBuilder s2 = new StringBuilder();
s1.append(s);
s2.append(s);
System.out.println("s1.equals(s2):\t\t" + (s1.equals(s2)));
System.out.println("s1 == s2:\t\t" + (s1 == s2));
 
String s3 = s + "1";
String s4 = s + "1";
System.out.println("s3 == s4:\t\t" + (s3 == s4));
System.out.println("s3.equals(s4):\t\t" + (s3.equals(s4)));
 
Object obj1 = new Object();
Object obj2 = new Object();
System.out.println("obj1.equals(obj2):\t" + (obj1.equals(obj2)));
System.out.println("obj1 == obj2:\t\t" + (obj1 == obj2));

 

执行结果如下

s1.equals(s2): //     false
s1 == s2:     //  false
s3 == s4:     //  false
s3.equals(s4):   //   true
obj1.equals(obj2):  //false
obj1 == obj2:       //false

  有人说“==比较地址，equals比较内容”，从String的比较来看这是对的，但从上述StringBuilder来看，s1和s2的构造方式一模一样，其内容是相同的，但是equals的结果却是false，为何？

我们有必要看一下Object类的equals方法的实现：

public boolean equals(Object obj) {
    return (this == obj);
}

 Object中的equals就是用==来比较当前对象和传入的参数的。

再看看String的equals实现：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
}

 它去比较内容了。

再看StringBuilder，在其源码里没有发现equals方法，那么它就继承了Object的实现，用==来比较传进来的参数。

我们看到equals是个实例方法（非static），实例方法是可以被子类重写而去实现自己想要的行为的，因此，不能轻易的说equals就是比较内容的，其行为是特定于实现的。但==确实是比较地址的。因为java中不支持（至少现在不支持）运算符重载，我们不能改变==的含义，其行为是固定死的。

记得下次不要说“==比较地址，equals比较内容”这样的话了，如果要说，也在前面加上特定的条件，如“如果比较String”，勿断章取义。