java - 工具类 - StringBuffer，StringBuilder

String可以像基本类型一样直接赋值，而且有不可变特性（长度内容不变），每次修改会重新生成新对象然后赋值，多次修改效率很低。

StringBuffer，StringBuilder，继承接口：Serializable, CharSequence，Appendable

String，继承了接口：Serializable，CharSequence，Comparable

所以StringBuffer比String少了 compareTo方法，多了append方法。

compareTo： 用来比较

append：用来拼接

StringBuffer： StringBuilder是他的进化版，和他用法区别不大更安全一些，相对的效率低一些。

本质也是char[]，但是没有final修饰，所以可以动态扩容。

package stringtest;

public class StringBufferTest {
    public static void main(String[] args){

        //String中没有的方法：
        StringBuffer sb = new StringBuffer("abc");
        System.out.println(sb.append(1==1));//拼接，很多类型都可以包括boolean
        //abctrue
        System.out.println(sb.insert(2,"def"));//插入位置char[2]，字段def,
        //abdefctrue   第二个字母后插入
        System.out.println(sb.delete(2,4));//删除范围[2-4）
        //abfctrue   ab|de|fctrue 删除了char[2]，char[3]
        System.out.println(sb.deleteCharAt(2));//删除char[2]
        //abctrue
        System.out.println(sb.reverse());//反转
        //eurtcba

        System.out.println(sb.capacity());//当前使用的容量：3 + 16 = 19 最开始定义时长度是3，只要不超过19就不会改变
        //StringBuffer 初始容量为定义字符串长度+16，用无参数构造函数则为16.
        sb.ensureCapacity(20);
        //确保能满足多大的空间，不够则扩容= =基本用不到。因为会自动扩容，不过可以用提前扩容来提高效率
        //每次扩容
        // 如果new > old * 2 + 2 则新容量为new
        // 如果new < old * 2 + 2 则新容量为  old * 2 + 2
        System.out.println(sb.capacity());//返回当前容量：19 * 2 + 2 = 40;

        sb.trimToSize();//去掉多余空间，只保留当前长度
        System.out.println(sb.capacity());
        //7  现在sb里是eurtcba，长度为7，所以只保留7
        sb.setLength(6);
        System.out.println(sb);
        System.out.println(sb.capacity());
        //eurtcb    长度变为6所以最后一个被删了
        //7         长度改变后，不超过容量就不会改变
        sb.setLength(8);
        System.out.println(sb + "!");
        System.out.println(sb.capacity());
        //eurtcb  !    长度变为8，后面的用空格补充了
        //16           长度>7,所以自动增长了7 * 2 + 2

        StringBuffer sbEfficiency1 = new StringBuffer("abc");
        StringBuffer sbEfficiency2 = new StringBuffer("abc");
        sbEfficiency2.ensureCapacity(200000000);//提前增加2000万
        System.out.println(sbEfficiency1.capacity());  //19
        System.out.println(sbEfficiency2.capacity()); // 50 > (3+16) * 2 + 2 所以新容量为50

        Long time1 = System.currentTimeMillis();//显示系统当前时间，进行运行效率比较。
        for(int i = 0; i < 1000000; i++) { //100万次
            sbEfficiency1.append("12345678901234567890");//添加了20个字符
        }
        Long time2 = System.currentTimeMillis();
        for(int i = 0; i < 1000000; i++) { //100万次
            sbEfficiency2.append("12345678901234567890");//添加了20个字符
        }
        Long time3 = System.currentTimeMillis();

        System.out.println(time2 - time1);
        System.out.println(time3 - time2);
        //第一次：
        //71
        //26
        //第二次：
        //61
        //26
        //第三次：
        //78
        //21
        //提前扩容速度明显要快一些

        //String中也有但是效果不同
        String a = "abcde";
        StringBuffer b = new StringBuffer("abcde");

        String s1 = a.substring(1,3);
        System.out.println(s1);
        String s2 = b.substring(1,3);//StringBuffer结束后返回的是String，效果一样
        System.out.println(s2);
        //bc
        //bc

    }
}

原文地址：https://www.cnblogs.com/clamp7724/p/11625352.html