String、StringBuilder与StringBuffer的区别

1.String类是public、final修饰的。

在Java中，被final修饰的类是不允许被继承的，并且String它的成员方法都默认为final方法。

查看源码得知，String类其实是通过char数组来保存字符串的。

对所有的String对象操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。

也就是说进行这些操作后，最原始的字符串并没有被改变，String类是不可变类。

如果我们用String来操作字符串的时候，一旦我们字符串的值改变，就会在内存创建多一个空间来保存新的字符串，因此频繁操作String效率会很低。

对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象。

package com.rong.se;

public class UseString {

    /**
     * String操作
     * @author 容杰龙
     */
    public static void main(String[] args) {
        String string="rong-jie-long";
        //String重载很多构造方法，不列举。。。
        String str=new String("abc well");
        
        char ch = str.charAt(0);
        System.out.println(ch);
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);
        int codePointBefore = str.codePointBefore(1);
        System.out.println(codePointBefore);
        //相等返回0  比较大小
        int compareTo = str.compareTo("abc well");
        System.out.println(compareTo);
        int compareToIgnoreCase = str.compareToIgnoreCase("ABC WELL");
        System.out.println(compareToIgnoreCase);
        //类似+
        String concat = str.concat(string);
        System.out.println(concat);
        //以什么开始
        boolean endsWith = str.endsWith("ll");
        System.out.println(endsWith);
        boolean startsWith = str.startsWith("abc");
        System.out.println(startsWith);
        //包括索引位置为5的字符
        String substring = string.substring(5);
        System.out.println(substring);
        String[] split = string.split("-");
        for (String string2 : split) {
            System.out.println(string2);
        }
        //限制最多分成几段
        String[] split2 = string.split("-", 3);
        for (String string2 : split2) {
            System.out.println(string2);
        }
        //比较是否相等，区分大小写
        boolean equals = str.equals(string);
        System.out.println(equals);
        //比较是否相等，不区分大小写
        boolean equalsIgnoreCase = str.equalsIgnoreCase(string);
        System.out.println(equalsIgnoreCase);
        int length = str.length();
        System.out.println(length);
        // 。。。。。。。。。。。。。。。。。。
    }

}

2.StringBuilder不支持并发操作，线程不安全的，不适合多线程中使用，但其在单线程中的性能比StringBuffer高，是可变类，

任何对它所指代的字符串的改变都不会产生新的对象。

package com.rong.se;

public class TestStringBuilder {

    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder sb=new StringBuilder();
        StringBuilder stringBuilder=new StringBuilder("abcdefg");
        sb.append(123);
        sb.append("hhh");
        sb.append(3.14159265354);
        System.out.println(sb.toString());
        //////////////////////////////
        System.out.println(sb.charAt(3));
        //可变类， 操作后仍然是同一个对象，只是内容不一样
        sb.delete(0, 10);//左闭右开,可返回对象，同一个对象
        System.out.println(sb);
        //删除索引位置字符,可返回对象，同一个对象
        StringBuilder deleteCharAt = sb.deleteCharAt(0);
        System.out.println(sb);
        //true,同一个对象
        boolean b = sb.equals(deleteCharAt);
        System.out.println(b);
        //获取字符串首次出现的索引位置
        int indexOf = sb.indexOf("53");
        System.out.println(indexOf);
        //从索引位置第几个开始插入字符串,可插入多种类型数据
        sb.insert(3, "www");
        sb.insert(3, 123.123);
        System.out.println(sb.toString());
        int lastIndexOf = sb.lastIndexOf("12", 6);
        System.out.println(lastIndexOf);
        System.out.println(sb.length());
        //替换。左闭右开原则。
        StringBuilder replace = sb.replace(0, 3, "r");
        System.out.println(replace);
        //反转
        sb.reverse();
        System.out.println(sb);
        // 从索引位置第n个起（包含n），截取字符串，生成新的字符串！！！
        String substring = sb.substring(10);
        System.out.println(substring);
        //转成String
        String string = sb.toString();
        System.out.println(string);
        
        
    }

}

3.StringBuffer则是可变类，是线程安全的，任何对它所指代的字符串的改变都不会产生新的对象。

 StringBuffer的操作与StringBuilder操作类似，基本相同。略。。。。。。

总结：

可变与不可变、线程安全与不安全、执行效率

String直接相加字符串，效率很高，因为在编译器便确定了它的值，形如"a"+"b"+"c"; 的字符串相加，在编译期间便被优化；对于间接相加（包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化

String、StringBuilder、StringBuffer三者的执行效率：StringBuilder > StringBuffer > String（相对而言）

　　   当字符串相加操作或者改动较少的情况下：String 

　　当字符串相加操作较多的情况下：StringBuilder

　　当程序采用了多线程：StringBuffer