不可变字符串String与可变字符串StringBuilder、StringBuffer使用详解

String字符串

char类型只能表示一个字符，而String可以表示字符串，也就是一个字符序列。但String不是基本类型，而是一个定义好的类，是一个引用类型。在Java中，可以将字符串直接量赋给String类型变量，也可以采用new String(parameter)的形式来创建字符串。

String str = "This is String”; //用字符串直接量赋值
String str = new String("Create a String through the Constructor"); //String的构造器来创建字符串

这里表示引用变量str，引用一个内容为This is String 的字符串对象。 但通常情况下，可直接称str变量是一个字符串，无须过于强调细节。

字符串特点：String类是不可变类，并且被final修饰，无法继承。 字符串对象都是不可变对象，所以对字符串进行操作时，都是返回新的字符串对象，原有字符串不会改变。

字符串在程序设计中用得非常频繁，所以掌握String字符串的常用方法是很有必要的。例如：

String普通方法

length()   　　　　 //返回字符串中的字符数，即字符串长度。
charAt(int index) //根据索引位置，返回对应字符。
toLowerCase() 　　 //把字符串中所有字母字符变成小写。
toUpperCase()     //把字符串中所有字母字符变成大写。
toCharArray()     //把字符串转成字符数组，即一个字符对应一个字符数组元素。
trim()            //消除字符串的两边空白字符。

        String s = "ABCDEF";
        System.out.println(s.length());  //
        System.out.println(s.charAt(0)); //索引位置0是 A
        String lowerCase = s.toLowerCase();
        System.out.println(lowerCase); //abcdef
        char[] ch = s.toCharArray();
        System.out.println(ch[0]); // A
        System.out.println("  ABC ".trim()); //ABC

 String比较方法

equals(Object anObject) 　　　　　　　　  //判断当前字符串对象与指定对象是否相等。

equalsIgnoreCase(String anotherString) //判断当前字符串对象与指定String 对象是否相等，忽略大小写。

compareTo(String anotherString)        //按字典顺序比较两个字符串。

compareToIgnoreCase(String str) 　　　　//按字典顺序比较两个字符串，忽略大小写 

boolean startsWith(String prefix) 　　　//判断是否以指定字符串作为前缀

boolean startsWith(String prefix, int toffset) //从指定的索引处开始，判断是否以指定字符串作为前缀

boolean endsWith(String suffix) 　　　　//当前字符串是否以指定字符串作为后缀。

contains(CharSequence s) 　　　　　　　　//如果包含指定字符串，则返回 true。否则false

注意：比较两个字符串内容是否相等时，很多人都会用 ==操作符来比较，但这是错的，下面说一下它们的区别。

==操作符和equals方法的区别

操作符==比较的是变量值是否相同，因为字符串是引用类型，所以操作符==只能检测两个字符串是否指向同一个引用（对象地址），但无法检测字符串对象的内容。操作符==只能用于判断基本类型以及引用类型是否为null。

要判断两个字符串变量是否相同，应该使用equals()方法来判断。两个对象指向同一引用，则说明内容相等。否则开始循环比较字符串内容。String的equals()方法实现细节：

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

        String s = "This is String";
        String s1 = s + ""; //产生一个新字符串
        System.out.println(s == s1); //两个字符串对象非同一个引用，返回false
        System.out.println(s.equals(s1)); //两个字符串对象的内容相等，返回true

总结一下就是：操作符==是直接比较变量的值。若是引用类型变量，则比较引用地址是否相同。而equals()方法是比较引用对象中的内容。

演示其他比较方法

        String s = "hello world";
        System.out.println(s.equalsIgnoreCase("HELLO WORLD")); //忽略大小写，比较字符串内容。true
        //轮流比较字符,字符不相等时，返回字符相减结果：e - a = 4 [69- 65]
        System.out.println(s.compareTo("hallo world"));
        //判断前缀
        System.out.println(s.startsWith("hello")); //true
        //判断后缀
        System.out.println(s.endsWith("worlds")); // false
        //是否包含指定字符串
        System.out.println(s.contains("lo wor")); //空白字符串也属于字符，别忽略了

除此之外，还有截取子字符串substring()、切割字符串split()、根据索引找字符串indexOf()、lastIndexOf()以及替换相应字符串replace()等等方法。若要了解更多方法，可查阅API。

转换字符串

有时候，我们需要将某个类型转成字符串来进行操作。例如将数值类型转成字符串，可以很快判断是几位数，可以快速判断是否是回文数。

方式有两种：采用操作符+拼接成字符串；通过静态方法valueOf(parameter)将相关类型转成对应字符串。

        String s1 = String.valueOf(123);
        String s2 = 123 +"";

采用操作符+直接转成字符串是最简洁、最方便的。

字符串直接量与new String()的区别

        String s1 = "ABC";
        String s2 = new String(s1); //等价于 new String("ABC");
        String s3 = s1 + "";
        System.out.println(s1 == s2); //false
        System.out.println(s1 == s3); //false

字符串直接量是一个字符串对象，而new String(s1)会构建一个同类型但不同内存空间的字符串对象。简单来说就是，两者没有指向同一个引用。所以操作符==判断为false。

s3 = s1 + ""; 这一段是运行时对字符串变量s1进行拼接，所以会产生一个新的字符串对象。所以为false。

关于对字符串直接量拼接是否相等同内容字符串

如果直接对字符串直接量进行拼接，而非采用变量形式拼接字符串，比较结果又会不同。

        String c = "C";
        String s1 = "ABC";
        String s2 = "AB" + c;
        String s3 = "A" + "B" + "C";
        System.out.println(s1 == s2); //false
        System.out.println(s1 == s3); //true

因为字符串是常量，所以创建“ABC”这个字符串时，会放在常量池中。 但s2指向的字符串对象引用是到运行时才会确定， 所以会导致创建一个新字符串对象。而s3是以字符串直接量来进行拼接，这些字符串在编译时就能确定下来，编译器就在常量池查找是否存在相同的字符串。若已存在，指向同一个字符串对象，否则，另外创建字符串。

除了操作符==判断引用地址外，可以使用System.identityHashcode() 查看内存地址是否相同，identityHashcode() 是根据内存地址生成的哈希值。

可变字符串StringBuilder、StringBuffer

String是不可变类，字符串都是常量，例如“ABC”会被存储在常量池中。对字符串进行任何更改操作都会产生新的String对象。而StringBuilder与StringBuffer是可变类，它们的字符串对象可以更改，对可变字符串的操作不会生成新的对象，即对同一个字符串对象操作。

StringBuilder、StringBuffer创建字符串

        StringBuilder sb = new StringBuilder(); //空字符串
        StringBuilder sb1 = new StringBuilder("字符串"); //以String对象作为参数构建字符串

StringBuilder与StringBuffer构建可变字符串对象都是通过new操作符调用构造方法，不能直接像String一样接收字符串直接量。

StringBuilder和StringBuffer的使用方式一模一样，两者只需要修改一下类名就可以无缝切换。两者的区别是StringBuilder应用于单线程环境，而StringBuffer应用于多线程环境。所以接下来只以StringBuilder作为示例。

可变字符串的常用方法（增删改查）

        append(data)　　　　　　　　//将给定数据作为字符串追加到可变字符串尾部
        insert(offset, data)      //将给定数据作为字符串追加到指定的偏移位置
        delete(start, end);       //删除start 到 end -1 的字符
        replace(start, end, str)  //替换start 到 end -1 的字符
        reverse();     　　　　　　 //将该字符串进行倒置
        sb.setCharAt(index, ch);; //设置 index 处的字符为给定字符

        StringBuilder sb = new StringBuilder(); //构建空的可变字符串
        sb.append("String is changed");
        System.out.println(sb); //原字符串对象内容被改变 String is changed
        //在下标0处插入123
        sb.insert(0, 123);
        System.out.println(sb); //123String is changed
        //删除 sb字符串的后面7位字符
        sb.delete(sb.length() - 7, sb.length());
        System.out.println(sb); //123String is
        //替换前三位字符
        sb.replace(0, 3, "!!!");
        System.out.println(sb); //!!!String is
        //翻转sb字符串
        sb.reverse();
        System.out.println(sb); // si gnirtS!!!
        //设置某个下标的字符内容
        sb.setCharAt(0,'A');
        System.out.println(sb); //Asi gnirtS!!!

可以看到，对可变字符串作出任何更改操作，都会对其字符串对象进行操作。 相比于String，若是需要大量使用字符串的场景，建议采用可变字符串，可以节省很多内存空间。

使用可变字符串的场景

1.将数组内容转成字符串

    public static String toStringWithArray(int[] arr) {
        StringBuilder sb = new StringBuilder("[");
        for(int i = 0; i < arr.length; i++) {
            if(i != arr.length -1) {
                sb.append(arr[i] + ", ");
            }else {
                sb.append(arr[i] + "]");
            }
        }
        return sb.toString();
    }

如果不采用可变字符串，那么在拼接字符串过程中，会产生很多用不到的字符串对象，很浪费内存空间。

凡是需要大量拼接字符串的地方，都应该尽量使用可变字符串来完成，因为效率高，而且不占内存空间。