1 字符串String類
1.1 String概述
字符串是一個對象，不是基礎數據類型（八大基礎數據類型：byte、int、short、long；float、double、char、boolean）。
字符串一旦被初始化，就不可以被改變，存放於方法區的常量池中。
String類重寫了Object類的equals()方法，用來判斷字符串的內容是否相同。
字符串String類代碼實例：
class StringDemo{
public static void main(String[] args){
String s1 = "abc"; //s1是一個類類型變量，"abc"是一個對象
//字符串最大特點：一旦被初始化，就不可以被改變。
s1 = "kk";
System.out.println(s1); //打印結果是"kk"，並不是字符串對象變了，而是s1指向的引用變了
//s1引用指向了新的"kk"字符串對象，而"abc"沒有再被引用。
String s2 = new String("kk"); //此定義格式等同於s1的定義格式，但也有區別。
/* s1和s2兩種定義方式什麼區別？
s1代表一個對象，
s2有兩個對象。new是一個對象，"kk"又是一個對象 */
System.out.println(s1==s2); //false，不是同一個對象的引用
System.out.println(s1.equals(s2)); //true，String類重寫了Object類中的equals方法，該方法判斷字符串內容是否相同。
}
}1.2 String類常用方法：獲取、判斷
String類是用於描述字符串的類，那麼它就提供了多個方法對字符串進行操作。
常見的方法有哪些：
1、獲取。
1.1 字符串中包含的字符數，也就是字符串的長度。
int length()：獲取字符串長度。
1.2 根據位置獲取位置上的某個字符。
char charAt(int index)：返回當前字符串第index位置上的字符。
1.3 根據字符獲取該字符在字符串中的位置。
int indexOf(int ch)：返回的是ch在字符串中第一次出現的位置，參數中的int類型是傳遞字符的ASCII值。
int indexOf(int ch, int fromIndex)：從fromIndex指定位置開始，獲取ch在字符串中出現的位置。
int indexOf(String str)：返回的是str在字符串中第一次出現的位置，str爲子串。
int indexOf(String str, int fromIndex)：從fromIndex指定位置開始，獲取子串str在字符串中出現的位置。
int lastIndexOf(int ch)：返回字符ch在當前字符串中最後一次出現時的位置。
若沒找到，返回-1.
2、判斷。
2.1 字符串中是否包含某一個子串。
boolean contains(String str);
特殊之處：indexOf(String str)：可以查找str第一次出現的位置，如果返回-1，表示該str不在字符串中存在。所以，也可以用於判斷字符串中是否包含某一個子串。
if(str.indexOf("aa")!= -1)
而且該方法既可以判斷，又可以獲取出現的位置。
2.2 字符串中是否有內容。
boolean isEmpty()：原理就是判斷長度是否爲0.
2.3 字符串是否是以指定內容開頭。
boolean startsWith(String str);
2.4 字符串是否是以指定內容結尾。
boolean endsWith(String str);
2.5 判斷字符串內容是否相同。重寫了Object類中的equals方法。
boolean equals(String str);
2.6 判斷字符串內容是否相同，並忽略大小寫。
boolean equalsIgnoreCase();
獲取和判斷的代碼示例：
class StringMethodDemo{
public static void method_get(){
String str = "abcdeabpf";
sop(str.length()); //返回字符串str的長度
sop(str.charAt(3)); //返回字符串str中腳標爲3的字符，即d
sop(str.indexOf('d'));//返回字符串str中，字符'd'的腳標。
sop(str.indexOf('a',4)); //從腳標爲4開始查找，返回字符'a'的腳標。
sop(str.indexOf("bcd")); //返回字符串str中，子字符串bcd的位置
sop(str.indexOf("ab",4));//從腳標爲4開始查找，返回子字符串"ab"在str中開始的腳標。
sop(str.lastIndexOf('a'));//返回字符'a'在字符串str中最後一次出現的腳標。
}
public static void method_is(){
String str = "ArrayDemo.java";
sop(str.contains("Demo"));//判斷字符串str中是否包含子串"Demo"
sop(str.isEmpty());//判斷字符串str是否爲空
sop(str.startsWith("Array"));//判斷字符串str是否以"Array"開頭
sop(str.endsWith(".java"));//判斷字符串str是否以".java"結尾
}
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
method_get();
sop(" ");
method_is();
}
}1.3 String類常用方法：轉換
3、轉換。
3.1 將字符數組轉成字符串。
構造函數：String(char[] value);
將字符數組value轉換成字符串並初始化。
String(char[] value, int offset, int count);
將字符數組中，從腳標offset開始，長度爲count的count個字符，轉換成字符串。
靜態方法：Static String copyValueOf(char[] data);
static String copyValueOf(char[] data, int offset, int count);
static String valueOf(char[] data);
static String valueOf(char[] data, int offset, int count);
3.2 將字符串轉成字符數組。**
char[] toCharArray();
3.3 將字節數組轉成字符串。
構造函數：String(byte[] b);
String(byte[] b, int offset, int count);
3.4 將字符串轉成字節數組。
byte[] getBytes();
3.5 將基本數據類型轉成字符串。
static String valueOf(int i);
static String valueOf(double d);
例如 3+""; //String.valueOf(3);
特殊：字符串和字節數組在轉換過程中，是可以指定編碼表的。
轉換方法的代碼示例：
class StringMethodDemo2{
public static void method_trans(){
char[] arr = {'a','b','c'};
String str1 = new String(arr); //把字符數組arr[]轉換成字符串。
String str2 = new String(arr,1,2); //把字符串arr[]中從腳標爲1開始的2個字符，轉換成字符串。
sop(str1);
sop(str2);
String str = "opqrst";
char[] arr2 = str.toCharArray(); //把字符串str轉換成字符數組arr2
byte[] arr3 = str.getBytes(); //把字符串str轉換成字節數組arr3
for(char element : arr2) //增強for循環遍歷數組
System.out.print(element+" ");
System.out.println(); //只爲換行
for(byte element : arr3)
System.out.print(element+" ");
}
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
method_trans();
}
}1.4 String類常用方法：替換、切割和獲取子串
4、替換。
String replace(char oldChar, char newChar);
用新的字符來替換當前字符串中舊的字符，返回新的字符串。
String replace(CharSequence target, CharSequence replacement);
CharSequence爲字符串接口，String類是其子類。
則CharSequence當然可接收String對象，即：
新的子字符串，替換舊的子串。
5、切割。
String[] split(String regex);
把當前字符串，以字符串regex爲依據，進行切割。返回切割後的字符串數組。
6、子串。獲取字符串中的一部分。
String substring(int beginIndex);
返回當前字符串中，從腳標 beginIndex 開始到結尾的子字符串。
String substring(int beginIndex, int endIndex)
返回當前字符串中，從腳標 beginIndex 到 endIndex-1 的子字符串。
beginIndex - 起始索引（包括）。
endIndex - 結束索引（不包括）。
替換、切割和獲取子串的代碼示例：
public class StringMethodDemo3{
public static void method_replace(){
String str = "hello java"; //str已經初始化，不能被改變，只能生成新的字符串
String str1 = str.replace('a','b'); //用'b'替換str中的'a'，新字符串對象的地址賦值給str1
String str2 = str.replace('p','b'); //如果要替換的字符不存在，返回的還是原串
sop(str1);
sop(str2);
String str3 = str.replace("java","world"); //用新的子字符串，替換舊的子串
sop(str3);
}
public static void method_split(){
String str = "zhangsanmmlisimmwangwu";
String[] arr = str.split("mm"); //把str字符串，以字符串"mm"爲依據，進行切割，返回字符串數組
for(int x=0; x<arr.length; x++)
sop(arr[x]);
}
public static void method_sub(){
String str = "abcdef";
String str1 = str.substring(2); //返回字符串str中，從腳標2開始到結尾的子字符串
String str2 = str.substring(2,4); //返回字符串str中，從腳標2到腳標3的子字符串
sop(str1);
sop(str2);
}
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
method_replace();
method_split();
method_sub();
}
}1.5 String類常用方法：轉換大小寫、去除空格、比較
7 將字符串轉成大寫或者小寫。
String toUpperCase(); //將當前字符串轉成全部大寫。
String toLowerCase(); //將當前字符串轉成全部小寫。
8 將字符串兩端的多個空格去除。
String trim(); //去除字符串兩端的多個空格。
9 對兩個字符串進行自然順序的比較。
int compareTo(String str);
按字典順序，比較兩個字符串中各個字符的Unicode值；
若當前String對象位於參數字符串之前，返回一個負數（第一個不同字符的ascii碼相減）；
若當前String對象位於參數字符串之後，返回一個正數；
若兩個字符串的順序相等，返回0.
如果此字符串按字典順序小於字符串參數，則返回一個小於 0 的值；
如果此字符串按字典順序大於字符串參數，則返回一個大於 0 的值。
如果參數字符串等於此字符串，則返回值 0；
轉換大小寫、去除兩端、比較字符串順序的代碼示例：
public class StringMethodDemo4{
public static void method_toUpperCase(){
String str = "Hello Java";
String str1 = str.toUpperCase(); //轉成全部大寫
sop(str1);
}
public static void method_toLowerCase(){
String str = "Hello Java";
String str1 = str.toLowerCase(); //轉成全部小寫
sop(str1);
}
public static void method_trim(){
String str = " Hello Java ";
String str1 = str.trim(); //去除兩端所有空格
sop(str1);
}
public static void method_compareTo(){
String str1 = "a1c"; //1 的ascii碼是49
String str2 = "aaa"; //a 的ascii碼是97
int s = str1.compareTo(str2); //1 的ascii值減 a的ascii值，第二個數不同則第二個之後的不再比較。返回-48
sop(s);
}
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
method_toUpperCase();
method_toLowerCase();
method_trim();
method_compareTo();
}
}2. 字符串緩衝區StringBuffer和StringBuilder
StringBuffer和StringBuilder是字符串緩衝區，是存放字符串的容器，都有相同的功能。
不同的是，StringBuffer考慮到了多線程的安全問題，而StringBuilder沒有，即StringBuffer是線程安全的，而StringBuilder是線程不安全的。
因爲StringBuffer考慮線程同步，需要判斷鎖，運行較慢。所以StringBuilder效率較高，但只能在單線程時使用。
單線程使用StringBuilder，多線程使用StringBuffer。
它們的常用功能有：存儲、刪除、獲取、修改、反轉、getChars()。
特點：
1，它們的長度是可變化的，而數組的長度是不可變化的。
2，可以直接操作多個數據類型。
3，最終會通過toString()方法變成字符串。
常見的四大操作——CURD：Create、Update、Read、Delete。
1，存儲：
append(數據)：將指定數據（任意類型）作爲參數添加到已有數據的結尾處。
insert(index,數據)：可以將數據（任意類型）插入到指定index的位置。
2，刪除：
delete(start,end)：刪除緩衝區中的數據，包含start不包含end。
deleteCharAt(index)：刪除指定位置的字符。
3，獲取：
charAt(int index)：通過腳標獲取字符。
indexOf(String str)：獲取子串str在當前字符串中的位置。
substring(int start)：獲取子串，從start到結尾。
substring(int start,int end)：獲取子串，從start到end，包含start不包含end。
4，修改：
replace(int start, int end, String str)：把從start到end的部分替換爲str，包含start不包含end，返回的依然是StringBuffer。
setCharAt(int index, char ch)：把index位置的字符替換爲ch。
5，反轉：
reverse()：把緩衝池中的字符串反轉，返回依然是StringBuffer。
6，將緩衝區中指定數據存儲到指定字符數組中：
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：把緩衝區中字符串從srcBegin到srcEnd（包含頭不包含尾）存到字符數組dst[]中，從數組的dstBegin腳標位開始存。
StringBuffer和StringBuilder常用方法示例：
class StringBufferDemo{
public static void main(String[] args){
method_getChars();
}
public static void sop(Object obj){
System.out.println(obj);
}
//StringBuffer的存儲：append、insert。
public static void method_add(){
StringBuffer sb = new StringBuffer(); //append從字符串緩衝池尾部開始添加字符。
sb.append("abc").append(true).append(34); //把"abc"、true和34轉換成字符串，依次加入字符串緩衝池。
sop("緩衝區中的字符串："+sb);
sb.insert(1,22); //在字符串腳標爲1的位置插入22.
sop("insert操作後："+sb);
}
//StringBuffer的刪除：delete。
public static void method_del(){
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);
sop("緩衝區中的字符串："+sb);
sb.delete(3,7); //刪除腳標從3到7的字符，包含3不包含7。
sop("delete操作後："+sb);
sb.delete(0,sb.length()); //清空緩衝區，容器StringBuffer消失了。
sop(sb.length());
}
//StringBuffer的獲取：charAt()、indexOf()、substring()。
public static void method_get(){
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);
sop("緩衝區中的字符串："+sb);
char arr = sb.charAt(2); //獲取腳標爲2的字符。
int index = sb.indexOf("34"); //獲取字符串"34"的位置
String str = sb.substring(3); //獲取從腳標3到末尾的子串
sop("腳標爲2的字符：........"+arr);
sop("34的位置：............."+index);
sop("子串：................."+str);
}
//StringBuffer的修改：replace(start,end,str)、setCharAt(index,char)。
public static void method_mo(){
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);
sop("緩衝區中的字符串："+sb);
sb.replace(3,7,"false"); //把從3到6的子串替換爲"false"
sb.setCharAt(sb.length()-1,'9'); //把最後一個字符替換爲'9'
sop("修改後：..............."+sb);
}
//StringBuffer的反轉：reverse()。
public static void method_re(){
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);
sop("緩衝區中的字符串："+sb);
sb.reverse();
sop("反轉後：..............."+sb);
}
//6，getChars(start,end,char[],index)：
public static void method_getChars(){
StringBuilder sb = new StringBuilder();
sb.append("abc").append(true).append(34);
sop("緩衝區中的字符串："+sb);
char[] arr = new char[6];
sb.getChars(3,7,arr,1); //把從3到6的字符串"true"存到字符數組arr[]中，從數組的腳標1開始存。
for(int x=0; x<arr.length; x++){
sop("arr["+x+"]="+arr[x]+"；");
}
}
}3 String類常用方法的練習
練習1，模擬一個trim()方法，去除字符串兩端的空格。
思路：
1，判斷字符串第一個位置是否是空格，如果是則繼續向下判斷，直到不是空格爲止。結尾處判斷空格也是如此。
2，當開始和結尾都判斷到不是空格時，就是要獲取的字符串。
練習2，將一個字符串進行反轉。將字符串中指定部分進行反轉，“abcdefg”；abfedcg
思路：
1，曾經學習過對數組元素進行反轉。
2，將字符串變成數組，對數組反轉。
3，將反轉後的數組變成字符串。
4，只要將反轉部分的開始和結束爲止作爲參數傳遞即可。
練習3，獲取一個字符串在另一個字符串中出現的次數，“abkkcdkkefkkgkk”
思路：
1，定義一個計數器。
2，獲取kk第一次出現的位置。
3，從第一次出現位置後剩餘的字符串中繼續獲取kk出現的位置。每獲取一次就計數一次。
4，當獲取不到時，計數完成。
練習4，獲取兩個字符串中最大相同子串。第一個動作：將短的那個串進行長度依次遞減的子串打印。“abcwerthelloyuiodef”，“cvhellobnm”
思路：
1，將短的那個字符串的子串按照長度遞減的方式獲取到。
2，將每獲取到的子串去長的字符串中判斷是否包含。如果包含，已經找到！
以上練習的代碼和註釋：
public class StringTest{
public static void main(String[] args){
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s1,s2));
}
public static void sop(Object obj){
System.out.println(obj);
}
//練習1，自己寫一個String的trim()方法
public static String myTrim(String str){
int start = 0, end = str.length()-1; //字符串的length()帶()
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
String str1 = str.substring(start,end+1);
return str1;
}
//練習2，將字符串反轉
public static String reverseString(String str,int start,int end){ //部分反轉
String str1 = str.substring(start,end+1);
String str2 = reverseString(str1);
char[] arr = str.toCharArray();
char[] arr1 = str2.toCharArray();
for(int x=start,i=0; x<=end && i<arr1.length; x++,i++){
arr[x] = arr1[i];
}
return new String(arr);
}
public static String reverseString(String str){ //全部反轉
char[] arr = str.toCharArray();
reverse(arr);
return new String(arr);
}
private static void reverse(char[] arr){ //數組順序反轉
for(int start=0,end=arr.length-1; start<end; start++,end--){ //數組的length不帶括號
char temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
//練習3，獲取一個字符串在另一個字符串中出現的次數
public static int getSubCount(String str,String key){ //獲取key在str中出現的次數
int count = 0;
int index = 0;
while((index=str.indexOf(key))!=-1){
sop("str:"+str);
str = str.substring(index+key.length());
count++;
}
return count;
}
//練習3，方式二：使用 indexOf(String str, int fromIndex)：從fromIndex指定位置開始，獲取str在字符串中出現的位置
public static int getSubCount2(String str,String key){
int count = 0;
int index = 0;
while((index=str.indexOf(key,index))!=-1){
sop("index:"+index);
index = index + key.length();
count++;
}
return count;
}
//練習4，以長度遞減的順序獲取較短字符串的所有子串，每獲取一個再依次判斷較長字符串是否也包含此子串。
public static String getMaxSubString(String s1,String s2){
String max="",min="";
max = (s1.length()>s2.length())?s1:s2;
min = (max==s1)?s2:s1;
sop("max="+max+"...min="+min);
String temp = "";
xunhuan:
for(int x=0; x<min.length(); x++){
for(int y=0,z=min.length()-x; z<=min.length(); y++,z++){
temp = min.substring(y,z); //返回從腳標 y 到（z-1）的子串。
//sop(temp);
if(max.contains(temp)) //if(max.indexOf(temp)!=-1)
break xunhuan;
}
}
return temp;
}
}