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