Java编程思想(十二) —— 字符串之基本方法

来源：互联网发布：sql plus用户名和密码编辑：程序博客网时间：2024/06/03 23:42

字符串在编程中也是经常使用的。

1)不可变

其实查看API就会发现：

public final class Stringextends Objectimplements Serializable, Comparable<String>, CharSequence

多谢网友提醒，不是final不可变，我短路了，Strings are constant; their values cannot be changed after they are created。

http://blog.csdn.net/renfufei/article/details/16808775

为什么不可变，通过他人写的内容进行补充一下。

public class TestString {    static String upcase(String s){        return s.toUpperCase();    }    public static void main(String[] args) {        String s = "bbc";        String ss = upcase(s);        System.out.println(s);    }}

这里虽然s传参给了upcase方法，但是s并没有改变，传参的时候，s会复制一份引用，但是引用所指的对象却没有移动过。

再补充一下一些特别的东西。

由Java编程思想(一) —— 一切都是对象知道，内存分配中，堆是存放对象的地方，而对内存中还有一块特殊的存储区域，而常量存储区存储的是便有字符串，所以：

String a = "a";String b = "b";

虽然a，b看似两个不同的引用，存在栈区，但其实指向的都是堆中同样的String对象。

再看看这个：

    public static void main(String[] args) {        String s= "s";        String s2= "s";        String s3= new String("s");        String s4= new String("s");        System.out.println(s==s2);        System.out.println(s3==s2);        System.out.println(s3==s4);    }

==比较的是两个对象的地址，其实由上面的a,b指向同一对象知道，s==s2，而new String呢，不会理你堆中是不是有同样的"s"对象，没每new一次，都重新创建一个，所以s3，s4，s2是不会==的。

2)重载“+”与StringBuilder

其实，StringBuilder和StringBuffer的东西，在面试笔试题里面已经看过很多遍了，但是，但是，每次都会忘记，这属性的东西，虽然一测试可以知道效率问题，但是直接回答还是凭借记忆。前段时间在知乎看到一个在外国工作的女程序员妹纸用了英文的记忆，当时记住了，答案现在找不到。

public class Test{        public static void main(String[] args) {        String s = "bbc";               String ss = "ddt"+s+"sdf"+3;        System.out.println(ss);    }}F:\>javac Test.javaF:\>javap -c TestCompiled from "Test.java"public class Test {  public Test();    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V       4: return  public static void main(java.lang.String[]);    Code:       0: ldc           #2                  // String bbc       2: astore_1       3: new           #3                  // class java/lang/StringBuilder       6: dup       7: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V      10: ldc           #5                  // String ddt      12: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      15: aload_1      16: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      19: ldc           #7                  // String sdf      21: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      24: iconst_3      25: invokevirtual #8                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;      28: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;      31: astore_2      32: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;      35: aload_2      36: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V      39: return}

作者还真是厉害，反编译class，出来一大堆汇编，之前学过8086的看起来还是挺面熟的，代码里面发现竟然自己调用了StringBuilder。因为跟作者所说的思路，如果+是String的append反复，那么每每加上一个之后就会有新对象，最后产生很多没用的对象。

竟然默认调用了StringBuilder，那么是不是可以全部都用重载+呢？

public class Test{   public String plus(String[] array){        String s = null;        for (int i = 0; i < array.length; i++) {            s += array[i];         }        return s;    }        public String builder(String[] array){        StringBuilder sb = new StringBuilder();        for (int i = 0; i < array.length; i++) {            sb.append(array[i]);        }        return sb.toString();    }}反编译：Compiled from "Test.java"public class Test {  public Test();    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V       4: return  public java.lang.String plus(java.lang.String[]);    Code:       0: aconst_null       1: astore_2       2: iconst_0       3: istore_3       4: iload_3       5: aload_1       6: arraylength       7: if_icmpge     37      10: new           #2                  // class java/lang/StringBuilder      13: dup      14: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V      17: aload_2      18: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      21: aload_1      22: iload_3      23: aaload      24: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      27: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;      30: astore_2      31: iinc          3, 1      34: goto          4      37: aload_2      38: areturn  public java.lang.String builder(java.lang.String[]);    Code:       0: new           #2                  // class java/lang/StringBuilder       3: dup       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V       7: astore_2       8: iconst_0       9: istore_3      10: iload_3      11: aload_1      12: arraylength      13: if_icmpge     30      16: aload_2      17: aload_1      18: iload_3      19: aaload      20: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;      23: pop      24: iinc          3, 1      27: goto          10      30: aload_2      31: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;      34: areturn}

有没有发现，有默认的空参数的构造器Test();

plus方法，34 goto 4，4是i的初始化，然后再接下去运行，比较，不停地跳转，StringBuilder在循环中不停的构建。这样就有很多的StringBuilder对象浪费了。注意10那里，new的创建。

在看看，反汇编之后的build方法，循环中是没有new东西的，就只有一个StringBuilder对象。

这样分析之后，明显StringBuider在不停地对字符串进行操作是效率更高资源占用少的，如果只是简单的几个字符串合并，那可以用+。

这个例子用了反汇编之后看起来简单好多，其实有些比较是通过时间计算，当然也是可以的。

StringBuilder是在SE5版本引入，之前用的是StringBuffer，这笔试题经常有的东西，出现了，StringBuffer是线程安全的，这样开销就比StringBuilder大，所以不存在线程问题的时候，使用StringBuilder。

可以看看下面那个网址，这是知乎上的一个叫程序猎人写的（由化学读软件，这是一个很牛逼的选择）。里面就是StringBuffer VS StringBuilder。

https://gist.github.com/programus/1978494

这一看发现GitHub原来还有Gist这样好用的东西。类似于保存零散代码的仓库。