1.String类是public、final修饰的。
在Java中，被final修饰的类是不允许被继承的，并且String它的成员方法都默认为final方法。
查看源码得知，String类其实是通过char数组来保存字符串的。
对所有的String对象操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。
也就是说进行这些操作后，最原始的字符串并没有被改变，String类是不可变类。
如果我们用String来操作字符串的时候，一旦我们字符串的值改变，就会在内存创建多一个空间来保存新的字符串，因此频繁操作String效率会很低。
对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象。
1 package com.rong.se;
2
3 public class UseString {
4
5 /**
6 * String操作
7 * @author 容杰龙
8 */
9 public static void main(String[] args) {
10 String string="rong-jie-long";
11 //String重载很多构造方法，不列举。。。
12 String str=new String("abc well");
13
14 char ch = str.charAt(0);
15 System.out.println(ch);
16 int codePointAt = str.codePointAt(1);
17 System.out.println(codePointAt);
18 int codePointBefore = str.codePointBefore(1);
19 System.out.println(codePointBefore);
20 //相等返回0 比较大小
21 int compareTo = str.compareTo("abc well");
22 System.out.println(compareTo);
23 int compareToIgnoreCase = str.compareToIgnoreCase("ABC WELL");
24 System.out.println(compareToIgnoreCase);
25 //类似+
26 String concat = str.concat(string);
27 System.out.println(concat);
28 //以什么开始
29 boolean endsWith = str.endsWith("ll");
30 System.out.println(endsWith);
31 boolean startsWith = str.startsWith("abc");
32 System.out.println(startsWith);
33 //包括索引位置为5的字符
34 String substring = string.substring(5);
35 System.out.println(substring);
36 String[] split = string.split("-");
37 for (String string2 : split) {
38 System.out.println(string2);
39 }
40 //限制最多分成几段
41 String[] split2 = string.split("-", 3);
42 for (String string2 : split2) {
43 System.out.println(string2);
44 }
45 //比较是否相等，区分大小写
46 boolean equals = str.equals(string);
47 System.out.println(equals);
48 //比较是否相等，不区分大小写
49 boolean equalsIgnoreCase = str.equalsIgnoreCase(string);
50 System.out.println(equalsIgnoreCase);
51 int length = str.length();
52 System.out.println(length);
53 // 。。。。。。。。。。。。。。。。。。
54 }
55
56 } 2.StringBuilder不支持并发操作，线程不安全的，不适合多线程中使用，但其在单线程中的性能比StringBuffer高，是可变类，
任何对它所指代的字符串的改变都不会产生新的对象。
1 package com.rong.se;
2
3 public class TestStringBuilder {
4
5 public static void main(String[] args) {
6 //创建StringBuilder对象
7 StringBuilder sb=new StringBuilder();
8 StringBuilder stringBuilder=new StringBuilder("abcdefg");
9 sb.append(123);
10 sb.append("hhh");
11 sb.append(3.14159265354);
12 System.out.println(sb.toString());
13 //////////////////////////////
14 System.out.println(sb.charAt(3));
15 //可变类， 操作后仍然是同一个对象，只是内容不一样
16 sb.delete(0, 10);//左闭右开,可返回对象，同一个对象
17 System.out.println(sb);
18 //删除索引位置字符,可返回对象，同一个对象
19 StringBuilder deleteCharAt = sb.deleteCharAt(0);
20 System.out.println(sb);
21 //true,同一个对象
22 boolean b = sb.equals(deleteCharAt);
23 System.out.println(b);
24 //获取字符串首次出现的索引位置
25 int indexOf = sb.indexOf("53");
26 System.out.println(indexOf);
27 //从索引位置第几个开始插入字符串,可插入多种类型数据
28 sb.insert(3, "www");
29 sb.insert(3, 123.123);
30 System.out.println(sb.toString());
31 int lastIndexOf = sb.lastIndexOf("12", 6);
32 System.out.println(lastIndexOf);
33 System.out.println(sb.length());
34 //替换。左闭右开原则。
35 StringBuilder replace = sb.replace(0, 3, "r");
36 System.out.println(replace);
37 //反转
38 sb.reverse();
39 System.out.println(sb);
40 // 从索引位置第n个起（包含n），截取字符串，生成新的字符串！！！
41 String substring = sb.substring(10);
42 System.out.println(substring);
43 //转成String
44 String string = sb.toString();
45 System.out.println(string);
46
47
48 }
49
50 } 3.StringBuffer则是可变类，是线程安全的，任何对它所指代的字符串的改变都不会产生新的对象。
StringBuffer的操作与StringBuilder操作类似，基本相同。略。。。。。。
总结：
可变与不可变、线程安全与不安全、执行效率
String直接相加字符串，效率很高，因为在编译器便确定了它的值，形如"a"+"b"+"c"; 的字符串相加，在编译期间便被优化；对于间接相加（包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化
String、StringBuilder、StringBuffer三者的执行效率：StringBuilder > StringBuffer > String（相对而言）
当字符串相加操作或者改动较少的情况下：String
当字符串相加操作较多的情况下：StringBuilder
当程序采用了多线程：StringBuffer