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