深入java字符串

Java字符串类(java.lang.String)是Java中使用最多的类，也是最为特殊的一个类，很多时候，我们对它既熟悉又陌生。

 

一、从根本上认识java.lang.String类和String池

 

首先，我建议先看看String类的源码实现，这是从本质上认识String类的根本出发点。从中可以看到：

1、String类是final的，不可被继承。public final class String。

2、String类是的本质是字符数组char[], 并且其值不可改变。private final char value[];

然后打开String类的API文档，可以发现：

3、String类对象有个特殊的创建的方式，就是直接指定比如String x = "abc"，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫做"abc"对象的引用。

4、String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联，这个后面会讲述。

6、Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。下面是个系统内存示意图：

 

5、创建字符串的方式很多，归纳起来有三类：

其一，使用new关键字创建字符串，比如String s1 = new String("abc");

其二，直接指定。比如String s2 = "abc";

其三，使用串联生成新的字符串。比如String s3 = "ab" + "c";

 

二、String对象的创建

 

String对象的创建也很讲究，关键是要明白其原理。

原理1：当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。

 

原理2：Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。

 

原理3：使用直接指定或者使用纯字符串串联("+")来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

 

原理4：使用包含变量的表达式或concat来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。

 

另外，String的intern()方法是一个本地方法，定义为public native String intern(); intern()方法的价值在于让开发者能将注意力集中到String池上。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。

有几点问题请大家注意:

1.String a; 与String a=null在作为类变量时候是等价的,在局部变量则不同.null表示一个空引用,String a=null意思是在栈中声明了a,但是这个a没有指向任何地址.此时我们注意到String a 在栈中声明了a,但是也没有指向任何地址,但是java的语法检查如果在局部变量中,String a;是不能直接使用的,String a=null中的这个a可以直接使用.

2.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.

3.使用new String("")创建的对象会存储到堆中,是运行期新创建的.
4.使用只包含常量的字符串连接符如"aa"+"aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中.
5.使用包含变量的字符串连接符如"aa"+ s1创建的或使用concat连接的对象是运行期才创建的,存储在堆中.
6.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
一个是编译期,一个是运行期!

7.对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到String Pool中,
而且String Pool在运行期是可以动态扩展的.

 

三、认识trim()、intern()和concat()、“+”。

 

      认识空格、空串、null

 

下面看个例子：

/**
* Created by IntelliJ IDEA.<br>
* <b>User</b>: leizhimin<br>
* <b>Date</b>: 2008-6-2 22:14:16<br>
* <b>Note</b>: Please add comment here!
*/
public class StringTest {
     public static void main(String args[]) {
         //在池中和堆中分别创建String对象"abc",s1指向堆中对象
        String s1 = new String( "abc");
         //s2直接指向池中对象"abc"
        String s2 = "abc";
         //在堆中新创建"abc"对象，s3指向该对象
        String s3 = new String( "abc");
         //在池中创建对象"ab" 和 "c"，并且s4指向池中对象"abc"
        String s4 = "ab" + "c";
         //c指向池中对象"c"
        String c = "c";
         //在堆中创建新的对象"abc"，并且s5指向该对象
        String s5 = "ab" + c;

        String s6 = "ab".concat( "c");
        String s7 = "ab".concat(c);

        System.out.println( "------------实串-----------");
        System.out.println(s1 == s2); //false
        System.out.println(s1 == s3); //false
        System.out.println(s2 == s3); //false
        System.out.println(s2 == s4); //true
        System.out.println(s2 == s5); //false
        System.out.println(s2 == s6); //false
        System.out.println(s2 == s7); //false

        String b1 = new String("");
        String b2 = "";
        String b3 = new String("");
        String b4 = "".intern();
        String b5 = "" + "";
        String b6 = "".concat("");
        String b7 = "  ".trim();
        String b8 = "  ";
        String b9 = "    ".trim();

        System.out.println( "------------空串-----------");
        System.out.println(b1 == b2);   //false
        System.out.println(b1 == b3);   //false
        System.out.println(b2 == b3);   //false
        System.out.println(b2 == b4);   //true
        System.out.println(b2 == b5);   //true*
        System.out.println(b2 == b6);   //true*
        System.out.println(b2 == b7);   //false*
        System.out.println( "-----a----");
        System.out.println(b2.equals(b7));   //true
        System.out.println(b7 == b8);   //false
        System.out.println(b7 == b9);   //false
        System.out.println(b7.equals(b9)); //true
        System.out.println(b9 == null); //false

        System.out.println( "b8.trim():");
         for ( byte b : b8.getBytes()) {
            System.out.print( ">>>" + ( int) b + " ");
        }
        System.out.println( "\nb8.trim():");
         for ( byte b : b8.trim().getBytes()) {
            System.out.print( ">>>" + ( int) b + " ");
        }
        System.out.println( "\nb9.trim():");
         for ( byte b : b9.trim().getBytes()) {
            System.out.print( ">>>" + ( int) b + " ");
        }
    }
}

 

例1
    /*
    * "sss111"是编译期常量,编译时已经能确定它的值,在编译
    * 好的class文件中它已经在String Pool中了,此语句会在
    * String Pool中查找等于"sss111"的字符串(用equals(Object)方法确定),
    * 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在
    * String Pool中,然后把引用返回,付值给s1.
    * 
    */
    String s1 ="sss111"; 

    //此语句同上
    String s2 ="sss111";

    /*
    * 由于String Pool只会维护一个值相同的String对象
    * 上面2句得到的引用是String Pool中同一个对象,所以
    * 他们引用相等
    */
    System.out.println(s1 == s2); //结果为true


例2
    /*
    * 在java中,使用new关键字会创建一个新对象,在本例中,不管在
    * String Pool中是否已经有值相同的对象,都会创建了一个新的
    * String对象存储在heap中,然后把引用返回赋给s1.
    * 本例中使用了String的public String(String original)构造函数.
    */
    String s1 =new String("sss111"); 
    
    /*
     * 此句会按照例1中所述在String Pool中查找
     */
    String s2 ="sss111";
    
    /*
     * 由于s1是new出的新对象,存储在heap中,s2指向的对象
     * 存储在String Pool中,他们肯定不是同一个对象,只是
     * 存储的字符串值相同,所以返回false.
     */
    System.out.println(s1 == s2); //结果为false


例3
    String s1 =new String("sss111"); 
    /*
    * 当调用intern方法时，如果String Pool中已经包含一个等于此String对象
    * 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此
    * String对象添加到池中，并返回此String对象在String Pool中的引用.
    */
    s1 = s1.intern();
    
    String s2 ="sss111";
    
    /*
     * 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111"
     * 的字符串对象,s2也指向了同样的对象,所以结果为true
     */
    System.out.println(s1 == s2);


例4
    String s1 =new String("111"); 
    String s2 ="sss111";
    
    /*
    * 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了,
    * 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中,
    * 由于上边的s2="sss111"已经在String Pool中加入了"sss111",
    * 此句会把s3指向和s2相同的对象,所以他们引用相同.此时仍然会创建出
    * "sss"和"111"两个常量,存储到String Pool中.

    */
    String s3 ="sss"+"111";
    
    /*
     * 由于s1是个变量,在编译期不能确定它的值是多少,所以
     * 会在执行的时候创建一个新的String对象存储到heap中,
     * 然后赋值给s4.
     */
    String s4 ="sss"+ s1;
    
    System.out.println(s2 == s3); //true
    System.out.println(s2 == s4); //false
    System.out.println(s2 == s4.intern()); //true


例5
这个是The Java Language Specification中3.10.5节的例子,有了上面的说明,这个应该不难理解了
    package testPackage;
    class Test {
            public static void main(String[] args) {
                    String hello ="Hello", lo ="lo";
                    System.out.print((hello =="Hello") +"");
                    System.out.print((Other.hello == hello) +"");
                    System.out.print((other.Other.hello == hello) +"");
                    System.out.print((hello == ("Hel"+"lo")) +"");
                    System.out.print((hello == ("Hel"+lo)) +"");
                    System.out.println(hello == ("Hel"+lo).intern());
            }
    }
    class Other { static String hello ="Hello"; }

    package other;
    public class Other { static String hello ="Hello"; }

输出结果为true true
true
true
false
true

四、String的常见用法

 

字符串重编码

这个问题说来比较简单，转码就一行搞定，不信你看看，但究竟为什么要转码，是个很深奥的问题，看例子：

import java.io.UnsupportedEncodingException;

/**
* 字符串转码测试
*
* @author leizhimin 2009-7-17 10:50:06
*/
public class TestEncoding {
         public static void main(String[] args) throws UnsupportedEncodingException {
                System.out.println( "转码前，输出Java系统属性如下：");
                System.out.println( "user.country:" + System.getProperty( "user.country"));
                System.out.println( "user.language:" + System.getProperty( "user.language"));
                System.out.println( "sun.jnu.encoding:" + System.getProperty( "sun.jnu.encoding"));
                System.out.println( "file.encoding:" + System.getProperty( "file.encoding"));

                System.out.println( "---------------");
                String s = "熔岩博客";
                String s1 = new String(s.getBytes(), "UTF-8");
                String s2 = new String(s.getBytes( "UTF-8"), "UTF-8");
                String s3 = new String(s.getBytes( "UTF-8"));
                String s4 = new String(s.getBytes( "UTF-8"), "GBK");
                String s5 = new String(s.getBytes( "GBK"));
                String s6 = new String(s.getBytes( "GBK"), "GBK");
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(s3);
                System.out.println(s4);
                System.out.println(s5);
                System.out.println(s6);
        }
}

 

输出结果：

转码前，输出Java系统属性如下：
user.country:CN
user.language:zh
sun.jnu.encoding:GBK
file.encoding:UTF-8
---------------
熔岩博客
熔岩博客
熔岩博客
鐔斿博鍗氬
���Ҳ���
熔岩博客

Process finished with exit code 0

 

得出一结论：

a、转一个码，又用该码来构建一个字符串，是绝对不会出现乱码的，----你相当于没转。

b、转码与否，与字符串本身编码有关，字符串本身的编码与谁有关？----文件编码，或者你的IDE设置的编码有关。

在此，我用的IDEA开发工具，默认是UTF-8编码，但操作系统使用的是GBK，但没有问题，我只要按照UTF-8来读取我的字符串就不会有乱码。但是文件已经是UTF-8了，你非要转为GBK，不乱才怪！那有什么办法呢？在Windows下，用记事本或者Editplus打开后另存为（并修改编码方式即可）。

 

至于已经要从UFT-8转换为GBK，这就要靠内码转换工具了，是个比较复杂的问题，如果有谁想研究可以告诉我，一块研究研究。

/*****************************************************************************/
经常会问到的问题

1,"abc"与new String("abc");
String s = new String("abc");创建了几个String Object?(如这里创建了多少对象? 和一道小小的面试题 )
这个问题比较简单,涉及的知识点包括:
引用变量与对象的区别;
字符串文字"abc"是一个String对象;
文字池[pool of literal strings]和堆[heap]中的字符串对象.

引用变量与对象:除了一些早期的Java书籍和现在的垃圾书籍,人们都可以从中比较清楚地学习到两者的区别.A aa;语句声明一个类A的引用变量aa[我常常称之为句柄],而对象一般通过new创建.所以题目中s仅仅是一个引用变量,它不是对象.[ref 句柄,引用与对象]
Java中所有的字符串文字[字符串常量]都是一个String的对象.有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组,这也没有办法,因为字符串与字符数组存在一些内在的联系.事实上,它与字符数组是两种完全不同的对象.
System.out.println("Hello".length());
char[] cc={'H','i'};
System.out.println(cc.length);
字符串对象的创建:由于字符串对象的大量使用[它是一个对象,一般而言对象总是在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");
这里的输出显示,两个字符串文字保存为一个对象.就是说,上面的代码只在pool中创建了一个String对象.
现在看String s = new String("abc");语句,这里"abc"本身就是pool中的一个对象,而在运行时执行new String()时,将pool中的对象复制一份放到heap中,并且把heap中的这个对象的引用交给s持有.ok,这条语句就创建了2个String对象.
String s1 = new String("abc") ;
String s2 = new String("abc") ;
if( s1 == s2 ){ //不会执行的语句}
这时用==判断就可知,虽然两个对象的"内容"相同[equals()判断],但两个引用变量所持有的引用不同,
BTW:上面的代码创建了几个String Object? [三个,pool中一个,heap中2个.]
[Java2 认证考试学习指南 (第4版)( 英文版)p197-199有图解.]
2,字符串的+运算和字符串转换
字符串转换和串接是很基础的内容,因此我以为这个问题简直就是送分题.事实上,我自己就答错了.
String str = new String("jf"); // jf是接分
str = 1+2+str+3+4;
一共创建了多少String的对象?[我开始的答案:5个.jf,new,3jf,3jf3,3jf34]
首先看JLS的有关论述:
一,字符串转换的环境[JLS 5.4 String Conversion]
字符串转换环境仅仅指使用双元的+运算符的情况,其中一个操作数是一个String对象.在这一特定情形下,另一操作数转换成String,表达式的结果是这两个String的串接.
二,串接运算符[JLS 15.18.1 String Concatenation Operator + ]
如果一个操作数/表达式是String类型,则另一个操作数在运行时转换成一个String对象,并两者串接.此时,任何类型都可以转换成String.[这里,我漏掉了"3"和"4"]
如果是基本数据类型,则如同首先转换成其包装类对象,如int x视为转换成Integer(x).
现在就全部统一到引用类型向String的转换了.这种转换如同[as if]调用该对象的无参数toString方法.[如果是null则转换成"null"].因为toString方法在Object中定义,故所有的类都有该方法,而且Boolean, Character, Integer, Long, Float, Double, and String改写了该方法.
关于+是串接还是加法,由操作数决定.1+2+str+3+4 就很容易知道是"3jf34".[BTW :在JLS的15.18.1.3中举的一个jocular little example,真的很无趣.]
下面的例子测试了改写toString方法的情况..
class A
{ int i = 10;
public static void main(String []args)
{ String str = new String("jf");
str += new A();
System.out.print(str);
}
public String toString(){ return " a.i ="+i+"\n"; }
}
三,字符串转换的优化
按照上述说法,str = 1+2+str+3+4;语句似乎应该就应该生成5个String对象:
1+2 ＝3,then 3→Integer(3)→"3" in pool? [假设如此]
"3"+str(in heap) = "3jf" (in heap)
"3jf" +3 ,first 3→Integer(3)→"3" in pool? [则不创建] then "3jf3"
"3jf3"+4 create "4" in pool
then "3jf34"
这里我并不清楚3,4转换成字符串后是否在池中,所以上述结果仍然是猜测.
为了减少创建中间过渡性的字符串对象,提高反复进行串接运算时的性能,a Java compiler可以使用StringBuffer或者类似的技术,或者把转换与串接合并成一步.例如:对于 a + b + c ,Java编译器就可以将它视为[as if]
new StringBuffer().append(a).append(b).append(c).toString();
注意,对于基本类型和引用类型,在append(a)过程中仍然要先将参数转换,从这个观点看,str = 1+2+str+3+4;创建的字符串可能是"3","4"和"3jf34"[以及一个StringBuffer对象].
现在我仍然不知道怎么回答str = 1+2+str+3+4;创建了多少String的对象,.或许,这个问题不需要过于研究,至少SCJP不会考它.
3,这又不同:str = "3"+"jf"+"3"+"4";
如果是一个完全由字符串文字组成的表达式,则在编译时,已经被优化而不会在运行时创建中间字符串.测试代码如下:
String str1 ="3jf34";
String str2 ="3"+"jf"+"3"+"4";
if(str1 == str2) { System.out.println("str1 == str2"); }
else { System.out.println("think again"); }
if(str2.equals(str1)) System.out.println("yet str2.equals(str1)");
可见,str1与str2指向同一个对象,这个对象在pool中.所有遵循Java Language Spec的编译器都必须在编译时对constant expressions 进行简化.JLS规定:Strings computed by constant expressions (ý15.28) are computed at compile time and then treated as if they were literals.
对于String str2 ="3"+"jf"+"3"+"4";我们说仅仅创建一个对象.注意,"创建多少对象"的讨论是说运行时创建多少对象.
BTW:编译时优化
String x = "aaa " + "bbb ";
if (false) { x = x + "ccc "; }
x += "ddd ";
等价于: String x = "aaa bbb "; x = x + "ddd ";
//这个地方我自己进行了编译,不过和他的结论不一样,好像当用x+="ddd"的时候和直接的x="aaa"+"bbb"+"ddd" 不同,但是具体为什么我也不清楚,正在研究中...

4.public class StringTest {   
    public static void main(String[] args) {
        String s1 = new String("abc");
        //执行完第一句代码后，在内存中创建两个对象。
        //分析：首先Java会根据"abc"在String Pool（字符串池）中查找"abc"，如果没有该
        //字符串则在String Pool中创建一个对象。然后在通过new关键字在Java内存堆栈中创建
        //一个"abc"对象，并且由s1变量指向它。
        String s2 = "abc";
        //在执行第二句代码时，Java会依据上面的顺序首先在String Pool中查找"abc"，如果
        //找到有此项，则变量s2指向String Pool中的"abc"。
        String s3 = new String("abc");
        //在执行第三句代码时，Java首先也会在String Pool中查找"abc"对象，然后在内存堆栈
        //中创建一个新的对象"abc"并且s3变量指向它。
       
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s2 == s3);
        /*
        public String intern()返回字符串对象的规范化表示形式。
        一个初始时为空的字符串池，它由类 String 私有地维护。
        当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串
        （该对象由 equals(Object) 方法确定），则返回池中的字符串。
        否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。
         */
        System.out.println(s1 == s1.intern());
        //s1.intern()会返回s2的内存地址。所以此句代码会打印false。
        System.out.println(s2 == s2.intern());
        System.out.println(s1.intern() == s3.intern());
    }

}

5.public class StringTest2 {   
    public static void main(String[] args) {
        String hello = "hello";
        String hel = "hel";
        String lo = "lo";
       
        System.out.println(hello == "hel" + "lo");
        //在"+"两边都是常量字符串，则将两个字符串合并并且在String Pool中查找"hello"
        //并返回在String Pool中的内存地址正好也是hello变量的内存地址，所以第一句代码会输出true。
        System.out.println(hello == "hel" + lo);
        //如果在"+"两边有一边是引用类型变量，Java会将合并成一个字符串并且在堆栈中创建一个
        //新的对象并且返回内存地址，所以这句代码是输出false。
    }

}

6.不变类
String对象是不可改变的(immutable).有人对str = 1+2+str+3+4;语句提出疑问,怎么str的内容可以改变?其实仍然是因为不清楚:引用变量与对象的区别.str仅仅是引用变量,它的值??它持有的引用可以改变.你不停地创建新对象,我就不断地改变指向.[参考TIJ的Read-only classes.]
不变类的关键是,对于对象的所有操作都不可能改变原来的对象[只要需要,就返回一个改变了的新对象].这就保证了对象不可改变.为什么要将一个类设计成不变类?有一个OOD设计的原则:Law of Demeter.其广义解读是:使用不变类.只要有可能,类应当设计为不变类.