全面理解Java中的String数据类型

        1. 首先String不属于8种基本数据类型，String是一个对象。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

　　2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；

　　3. String str=”kvill”；
String str=new String (“kvill”);的区别：

　　在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。

　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　看例1：

String s0=”kvill”;
String s1=”kvill”;
String s2=”kv” + “ill”;
System.out.println( s0==s1 );
System.out.println( s0==s2 );

　　结果为：

true
true

　　首先，我们要知道Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。

　　所以我们得出s0==s1==s2;

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

　　看例2：

String s0=”kvill”;
String s1=new String(”kvill”);
String s2=”kv” + new String(“ill”);
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );

　　结果为：

false
false
false

　　例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

　　4. String.intern()：

　　再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

　　例3：

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 //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中”kvill”的引用
true

　　最后我再破除一个错误的理解：

　　有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

　　看例4：

String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );

　　结果：

false
kvill kvill
true

　　在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

　　s1==s1.intern()为false说明原来的“kvill”仍然存在；

　　s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

　　5. 关于equals()和==:

　　这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

　　6. 关于String是不可变的

　　这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;
就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的

评论

15 楼 laowang_27hotmail.com 2007-09-13  

细节,真的还要好好学啊

14 楼 itkui 2007-09-12  

谢了大家，String还是满耐研究的哦

13 楼 feng_gladys 2007-09-12  

<br/>
<div class='quote_div'><br/>
最后我再破除一个错误的理解： <br/>
<br/>
有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的： <br/>
<br/>
看例4： <br/>
<br/>
<table border='1' align='center' width='90%'>
    <tbody>
        <tr>
            <td>String s1=new String("kvill"); <br/>
            String s2=s1.intern(); <br/>
            System.out.println( s1==s1.intern() ); <br/>
            System.out.println( s1+" "+s2 ); <br/>
            System.out.println( s2==s1.intern() ); </td>
        </tr>
    </tbody>
</table>
<br/>
结果： <br/>
<br/>
<table border='1' align='center' width='90%'>
    <tbody>
        <tr>
            <td>false <br/>
            kvill kvill <br/>
            true </td>
        </tr>
    </tbody>
</table>
<br/>
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。 <br/>
<br/>
s1==s1.intern()为false说明原来的“kvill”仍然存在； <br/>
<br/>
s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。 <br/>
<br/>
</div>
s1 = new String("kill");这段代码是产生两个对象，一个是“kill”，该对象存入常量池中，另一个是复制“kill”的值新产生一个对象（new）并返回给s1，所以s1=new String(“kill”);实际上已经在常量池里注册了一个“kill”。<br/>
<br/>
String构造函数：<br/>
<h3> String</h3>
<pre>public String(<a title='class in java.lang'>String</a> original)</pre>
<dl><dd>Initializes a newly created <code>String</code> object so that it  represents the same sequence of characters as the argument; in other  words, the newly created string is a copy of the argument string. Unless   an explicit copy of <code>original</code> is needed, use of this   constructor is unnecessary since Strings are immutable.
<p> </p>
<dl><dt>Parameters:</dt><dd><code>original</code> - a <code>String</code>.</dd></dl> </dd></dl>the newly created string is a copy of the argument string  这句话说明原因

12 楼 Calmfeeling 2007-09-11  

呵呵，不是太全面...
面试么，离不开String ,StringBuffer,==&&equals的区别

11 楼 xuehongliang 2007-09-11  

还是对理解string类型有帮助的。

10 楼 hwangita 2007-09-11  

写的还是可以的

9 楼 抛出异常的爱 2007-09-11  

引用

字符串字面量通过+运算符，sun的编译器会进行优化，"a"+"b"+"c"在编译后优化为"abc"，而非字面量的字符串使用+运算符将产生新的String，这个真的已经讨论烂了。

这么设计有一个好处
就是当把字符串当参数传给一个方法时
不用担心这个方法会改变这个字符串的内容

public void zz(String p){
  p += "a";//这时的p与外面的那个P的地址变的不同了。
}

外面的p的内容就被保护了。

8 楼 itkui 2007-09-09  

birdjavaeye 写道

明确说明一下，第6点理论上那样，但在现在的Sun JDK的javac实现上不是那样

"a" + new String("b") + "c"

只会产生"a"、"b"、"c"和最后的"abc"，没有中间的"ab"
因为sun的javac把上面代码编译成了：

new StringBuilder("a").append(new String("b")).append("c").toString()

真正遵循规范的+要这么写：
"a".concat("b").concat("c")这样才会产生"ab"这个字符串

所以实际应用中，完全不要担心"a" + "b" + "c"这样的写法
但要注意类似下面的东西：
for (String x = ...)
  s = s + x;
这个每次循环都会生成一个字符串，这时改成s.append(x)才好

知道了，谢谢！

7 楼 itkui 2007-09-09  

birdjavaeye 写道

明确说明一下，第6点理论上那样，但在现在的Sun JDK的javac实现上不是那样

"a" + new String("b") + "c"

只会产生"a"、"b"、"c"和最后的"abc"，没有中间的"ab"
因为sun的javac把上面代码编译成了：

new StringBuilder("a").append(new String("b")).append("c").toString()

真正遵循规范的+要这么写：
"a".concat("b").concat("c")这样才会产生"ab"这个字符串

所以实际应用中，完全不要担心"a" + "b" + "c"这样的写法
但要注意类似下面的东西：
for (String x = ...)
  s = s + x;
这个每次循环都会生成一个字符串，这时改成s.append(x)才好

知道了，谢谢！

6 楼 dennis_zane 2007-09-09  

字符串字面量通过+运算符，sun的编译器会进行优化，"a"+"b"+"c"在编译后优化为"abc"，而非字面量的字符串使用+运算符将产生新的String，这个真的已经讨论烂了。

5 楼 birdjavaeye 2007-09-09  

明确说明一下，第6点理论上那样，但在现在的Sun JDK的javac实现上不是那样

"a" + new String("b") + "c"

只会产生"a"、"b"、"c"和最后的"abc"，没有中间的"ab"
因为sun的javac把上面代码编译成了：

new StringBuilder("a").append(new String("b")).append("c").toString()

真正遵循规范的+要这么写：
"a".concat("b").concat("c")这样才会产生"ab"这个字符串

所以实际应用中，完全不要担心"a" + "b" + "c"这样的写法
但要注意类似下面的东西：
for (String x = ...)
  s = s + x;
这个每次循环都会生成一个字符串，这时改成s.append(x)才好

4 楼 itkui 2007-09-09  

Eastsun 写道

想要全面&正确理解String,看<The Java™ Language Specification>是最好的方法.

谢了哥们，下了，有用的到的时候再看看。

3 楼 Eastsun 2007-09-09  

想要全面&正确理解String,看<The Java™ Language Specification>是最好的方法.

2 楼 itkui 2007-09-09  

wang20051 写道

好文,让我对String 数据类型理解更深刻

这几天面试，都是问些基础的东西，所以就在网上找找看看。

1 楼 wang20051 2007-09-09  

好文,让我对String 数据类型理解更深刻