1、String类
想要了解一个类，最好的办法就是看这个类的实现源代码，String类的实现在\jdk1.6.0_14\src\java\lang\String.java 文件中。打开这个类文件就会发现String类是被final修饰的：
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
/** The value is used for character storage. */
private final char value[];
/** The offset is the first index of the storage that is used. */
private final int offset;
/** The count is the number of characters in the String. */
private final int count;
/** Cache the hash code for the string */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
......
}
从上面可以看出几点：
- String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。在早期的JVM实现版本中，被final修饰的方法会被转为内嵌调用以提升执行效率。而从Java SE5/6开始，就渐渐摈弃这种方式了。因此在现在的Java SE版本中，不需要考虑用final去提升方法调用效率。只有在确定不想让该方法被覆盖时，才将方法设置为final。
- 上面列举出了String类中所有的成员属性，从上面可以看出String类其实是通过char数组来保存字符串的。
下面再继续看String类的一些方法实现：
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
char buf[] = new char[count + otherLen];
getChars(0, count, buf, 0);
str.getChars(0, otherLen, buf, count);
return new String(0, count + otherLen, buf);
}
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = count;
int i = -1;
char[] val = value; /* avoid getfield opcode */
int off = offset; /* avoid getfield opcode */
while (++i < len) {
if (val[off + i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0 ; j < i ; j++) {
buf[j] = val[off+j];
}
while (i < len) {
char c = val[off + i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(0, len, buf);
}
}
return this;
从上面的三个方法可以看出，无论是sub操、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。在这里要永远记住一点：
对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
2、深入理解String
先看如下代码：
public class Main {
public static void main(String[] args) {
String str1 = "abcd";//line 1
String str2 = new String(str1);// line 2
String str3 = "abcd";//line 3
String str4 = new String("abcd"); //line 4
String str5 = str1;//line 5
str5 = str5.concat("ef");//line 6
System.out.println(str1==str3);
System.out.println(str1==str2);
System.out.println(str2==str4);
System.out.println(str1==str5);
System.out.println(str1.equals(str3));
System.out.println(str1.equals(str2));
System.out.println(str2.equals(str4));
System.out.println(str1.equals(str5));
}
}
这些语句会发生什么事情? 大概是这样的:
- line 1 line 3:分配一个长度为4的char数组，并在常量池分配一个由这个char数组组成的字符串，然后由str1去引用这个字符串。用str3去引用常量池里边的字符串，所以str1和str3引用的是同一个对象。
- line 2:在堆内存中开辟一个新的空间，但内部的字符数组引用着str1内部的字符数组。
- line 4:同样会在堆内存中开辟一个新的空间，但内部的字符数组引用常量池里边的字符串内部的字符数组，意思是和str2是同样的字符数组。
这段代码的输出结果为:true,fasle,fase,false,true,true,true,false。原因解释如下：
对于结果一：
字符串池是方法区中的一部分特殊存储。当一个字符串被被创建的时候，首先会去这个字符串池中查找，如果找到，直接返回对该字符串的引用。
图示如下：
String.png
对于结果四，图示如下：
-
定义一个字符串：
String-1.jpeg -
使用变量来赋值变量：
String-2.jpeg -
字符串连接：
string-3.jpeg
str5中保存的是一个重新创建出来的string对象的引用。
对于结果二、三：
总所周知，通过new关键字来生成对象是在堆区进行的，而在堆区进行对象生成的过程是不会去检测该对象是否已经存在的。因此通过new来创建对象，创建出的一定是不同的对象，即使字符串的内容是相同的。
对于equals比较结果：
解释参见下一篇博客Java基础之equals方法；
3、总结
特别要注意的是，String类是通过char数组来保存字符串的，即字符串内部是通过字符数组存储的，String类的所有方法都没有改变字符串本身的值，都是返回了一个新的对象。
