对String类的一些认识

可能以前一直对String类的一些认识不太够,所以感觉一直都不是很懂,最近看书,有了一些新的认识,所以记下来
在Java中,字符串是做为String类的实例出现的,其实字符串就是字符数组,
首先String对象有几个基本的方法,如

public class StringDemo {
    public static void main(String[] args) {
        String text = "hello";

        System.out.println("字符串内容:" + text);
        System.out.println("字符串长度:" + text.length());
        System.out.println("等于hello?" +
                                 text.equals("hello"));
        System.out.println("转为大写:" +
                                 text.toUpperCase());
        System.out.println("转为小写:" +
                                 text.toLowerCase());
    }
}

这很好理解,就不多说了,
因为字符串的本质就是字符数组,这样也就具有了数组索引的性质,如

public class CharAtString {
    public static void main(String[] args) {
        String text = "One's left brain has nothing right.\n"
                 + "One's right brain has nothing left.\n";

        System.out.println("字符串内容: ");
        for(int i = 0; i < text.length(); i++)
            System.out.print(text.charAt(i));

        System.out.println("\n第一个left: " +
                              text.indexOf("left"));
        System.out.println("最后一个left: " +
                              text.lastIndexOf("left"));

        char[] charArr = text.toCharArray();
        System.out.println("\n字符Array内容:");
        for(int i = 0; i < charArr.length; i++)
            System.out.print(charArr[i]);
    }
}

这也很好理解,略过,String对象里还有个endsWith()方法蛮有意思的

接着我想说的是,

字符串是不可变的
一个字符串对象一旦被配置,它的内容就是固定不可变的,如

String str = "Just";
str = "Justin";

上面的语句并没有改变一个字符串对象的内容,事实上在这个程序片段中会有两个字符串对象,一个是Just字符串对象, 一个是Justin字符串对象,两个是不同的字符串对象,
在Java中,使用"="将一个字符串对象指定给一个变量名称, 其意义为改变该名称所引用的对象,原来被引用的字符串对象若没有其它名称来引用它,就会在适当的时候被Java的"垃圾回收"机制回收.
在Java执行时会维护一个String Pool,对于一些可以共享的字符串对象,会先在String Pool中查找是否存在相同的String内容,如果有就直接返回,而不是直接创造一个新的String对象,以减少内存的耗用,
如果在程序中使用下面的方式来声明,则实际上是指向同一个字符串对象:

String str1 = "flyweight";
String str2 = "flyweight";
System.out.println(str1 == str2);

其结果会

true

注:   在Java中,如果==被使用于两个对象类型的变量,它是用于比较两个变量是否引用自同一对象.

在这还要提一上String的intern()方法,如

public class InternString {
    public static void main(String[] args) {
        String str1 = "fly";
        String str2 = "weight";
        String str3 = "flyweight";
        String str4 = null;

        str4 = str1 + str2;
        System.out.println(str3 == str4);

        str4 = (str1 + str2).intern();
        System.out.println(str3 == str4);
    }
}

其结果为

false
true

在Java中使用 + 串联字符串会产生一个新的字符串对象,所以在第一次比较str3 与 str4对象是否为同一个对象时,结果为false,

然, intern()方法会先检查String Pool中是否存在字符部分相同的字符串对象,如果有就返回,由于程序中之前已经声明flyweight字符串对象,intern()方法在String Pool中发现了它,所以直接返回,这时再比较,str3 与 str4 就指向同一个对象了,所以结果为true

另外提一点:

String str1 = new String("hello");
String str2 = new String("hello");
// System.out.println(str1 == str2);
System.out.println(str1.equals(str2);

如上,这才产生了两个不同的String对象,使用 == 在这是用来比较两个字符串对象是否指向同一对象的,要比较两个字符串对象内容是否相同要使用equals()方法

接下来我想说一下StringBuilder类的使用
这是在jdk5.0中新增的一个类,
一个String对象的长度是固定的,不能改变它的内容,或者是附加新的字符至String对象中,也许可以使用 + 来串联字符串以达到目的,但 + 会产生一个新的String对象, 如果程序对这种附加字符串的需求很频繁, 并不建议用 + 来串联,这时候,StringBuilder就派上用场了,不过在之前的版本中的StringBuffer也可以实现同样的操作.这样就可以让程序的效率大大提高,
现给出证明代码

public class AppendStringTest {
    public static void main(String[] args) {
        String text = "";

        long beginTime = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++)
            text = text + i;
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间：" + (endTime - beginTime));

        StringBuilder builder = new StringBuilder("");
        beginTime = System.currentTimeMillis();
        for(int i = 0; i < 10000; i++)
            builder.append(String.valueOf(i));
        endTime = System.currentTimeMillis();
        System.out.println("执行时间：" + (endTime - beginTime));
    }
}

其运行结果大概为:

执行时间: 4641
执行时间: 16

此差距是明显的,
说明一点的是,如果在单机非多线程的情况下使用StringBuilder会有较好的效率,因为StringBuilder没有处理同步问题
所以在多线程情况下就使用StringBuffer会好一些..

这就是我对String对象的一些认识,记下来而已..