Java常用類之字符串相關類使用詳解

package li.normalclass.stringclass;
 
import java.util.Arrays;
 
public class TestString {
    public static void main(String[] args) {
        // 1.如何創建String對象
        String str = "北京天安門abc";
 
        // 2.如何使用String對象
        // 2.1最簡單的方法
        System.out.println(str.length() );//8  註意是字符的個數，不是字節的個數
 
        //如果字符串為空返回 true，否則返回 false
        System.out.println(str.isEmpty());//false
 
        //jdk11新增的方法,如果給定的字符串為空或僅包含空格代碼點，則此方法返回 true ，否則返回 false
        System.out.println(str.isBlank());//false
 
        //是否已括號內的字符串為開始
        System.out.println(str.startsWith("北京天"));//true
 
        // 是否已括號內的字符串為結束
        System.out.println(str.endsWith("c"));//true
 
         //生成一個新的字符串,字符串的英文字符全部變小寫
        System.out.println(str.toLowerCase()); //北京天安門abc
 
        //生成一個新的字符串,字符串的英文字符全部變大寫
        System.out.println(str.toUpperCase());//北京天安門ABC
 
        /*
        註意：String是不可變字符序列，上面的方法改變的隻是新生成的字符串，這裡重新輸出str，依舊是原來的字符
         */
        System.out.println(str);//北京天安門abc
 
 
        //2.2根據索引找子串
        //charAt()方法返回指定索引位置的char值。索引范圍為0~length()-1
        char c = str.charAt(3);//註意下標從0開始
        System.out.println(c);//安
 
        //str.substring(int startIndex);
        //子字符串的下標從索引開始
        System.out.println(str.substring(2));//天安門abc
 
        //substring(int startIndex，int endIndex);
        /*返回一個字符串，該字符串是此字符串的子字符串。
         子串開始於指定beginIndex並延伸到字符索引endIndex- 1
          因此，子串的長度為endIndex-beginIndex
         */
        System.out.println(str.substring(5,8));//abc
 
        // 2.3根據子串找索引
        //public int indexOf(int ch)返回指定字符第一次出現的字符串內的第一個索引
        int index = str.indexOf("abc");
        System.out.println(index);//5
 
        //indexOf(String str, int fromIndex)
        //返回指定子串的第一次出現的字符串中的索引，從指定的索引開始。
        System.out.println(str.indexOf("門", 2));//4
 
        //從後向前查詢第一次遇到的指定字符串的索引位置，註意索引還是從前往後數起
        System.out.println(str.lastIndexOf("北"));//0
 
        // 2.4其他方法
       /* str.concat();
        str.trim();
        str.split();
        str.replace();
        str.replaceAll()等
        */
 
        //split(String regex)
        //split()方法:分割字符串,參數regex稱為分割符,可以使用正則表達式來表示
        String str2 = "Java,HTML,MySQL,Spring,java,Java";
        String arr [] = str2.split("S");
        System.out.println(Arrays.toString(arr));//[Java,HTML,My, QL,, pring,java,Java]
 
        //replace() 方法用於在字符串中用一些字符替換另一些字符，或替換一個與正則表達式匹配的子串。區分大小寫
        System.out.println(str2.replace("Java","javase"));//javase,HTML,MySQL,Spring,java,javase
 
        //public String replaceAll(String regex,String replacement)
        //用給定的替換替換與給定的regular expression匹配的此字符串的每個子字符串。
        //regex - 要匹配此字符串的正則表達式, replacement - 要替換每個匹配的字
        String str3 = "abc,adc,afffc,rty,acc";
        String str4 = str3.replaceAll("a...c","#");
        System.out.println(str4);//abc,adc,#,rty,acc
 
        //trim()去掉字符串兩邊的空格
        String str5 = "  rbg  ni     men   hao    ";
        System.out.println(str5.length());//27
        System.out.println(str5.trim());//去掉字符串兩端的空格  "rbg  ni     men   hao"
        System.out.println(str5.trim().length());//21
 
        //toCharArray()
        char [] chArr = str.toCharArray();//str = "北京天安門abc"
        System.out.println(chArr);
        System.out.println(chArr[2]);//天
 
 
        //concat()方法，在字符串的末尾追加子串
        String str6 = "北京市";
        str6 = str6.concat("紫禁城").concat("故宮").concat("博物院");
        System.out.println(str6);//北京市紫禁城故宮博物院
        
        //contains() 當且僅當此字符串包含指定的char值序列時，返回true
        System.out.println( str6.contains("博物院"));//true
        
        /*compareTo()方法
        返回比較的前後兩個字符串的ASCII碼的差值，如果兩個字符串首字母不同，則該方法返回首字母的ASCII碼的差值
        如果首字符相同，則比較下一個字符，直到有不同的為止，返回該不同的字符的ASCII碼差值。
        如果兩個字符串不一樣長，可以參與比較的字符又完全一樣，則返回兩個字符串的長度差值。
        返回為正數表示a1>a2, 返回為負數表示a1<a2, 返回為0表示a1==a2
         */
        String str1 = "jsdy";
        String str2 = "jsdr";
 
        System.out.println(str1.compareTo(str2));//7
        
    }
}

package li.normalclass.stringclass;
 
public class TestString2 {
    public static void main(String[] args) {
        //equals
        String str1 = new String ("jsdy");
        String str2 = new String ("jsdy");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true
 
        String str3 = "jsdy";
        String str4 = "jsdy";
        System.out.println(str3==str4);//ture!!!
        System.out.println(str3.equals(str4));//true
 
        String str5 = new String ("jsdy");
        String str6 = "jsdy";
        System.out.println(str5==str6);//false
        System.out.println(str5.equals(str6));//true
        
         String str7 = null;//沒有指向任何內容
        String str8 = new String("");
        String str9 = "";//指向一個空字符串
        System.out.println(str9.length());//0
        //System.out.println(str7.length())-->java.lang.NullPointerException
        System.out.println(str8==str9);//false
        System.out.println(str8.equals(str9));//true
 
    }
}

String str3 = "jsdy";
String str4 = "jsdy";
System.out.println(str3==str4);//ture!!!

String str1 = new String ("jsdy");
String str2 = new String ("jsdy");
System.out.println(str1==str2);//false
System.out.println(str1.equals(str2));//true

//concat()方法，在字符串的末尾追加子串
        String str6 = "北京市";
        str6 = str6.concat("紫禁城");
        str6 = str6.concat("故宮");
        str6 = str6.concat("博物院");
        System.out.println(str6);//北京市紫禁城故宮博物院

package li.normalclass.stringbuilder;
 
/*
    StringBuilder用得比較多的基本上就是這三個常見操作：
    1.創建對象
        StringBuilder builder = new StringBuilder("xxx");
    2.末尾追加字符串
        builder.append("yyy");
    3.轉換為字符串
        String str = builder.toString()
        System.out.println(str)
 */
public class TestStringBuilder1 {
    public static void main(String[] args) {
        //創建StringBuilder對象
 
        /*
        創建Builder對象時，底層的數組大小實際為輸入的字符串長度個數+16
         */
        StringBuilder builder = new StringBuilder("北京");
 
        //length是字符的個數，capacity是底層數組的長度
        System.out.println(builder.length()+"\t"+ builder.capacity());//2  （2+16=）18
 
        //操作StringBuilder對象
        //操作：字符串末尾增加
 
        builder.append("故宮博物院");
        System.out.println(builder.length()+"\t"+ builder.capacity());//7  18
 
        builder.append("墻角下的");
        //---->這裡擴容瞭，擴容方法是：當前字符串長度*2+2，在這裡既是18*2+2=38
        System.out.println(builder.length()+"\t"+ builder.capacity());//11 38
 
        builder.append("一隻懶貓在睡覺覺");
        System.out.println(builder.length()+"\t"+ builder.capacity());//19 38
 
 
        //操作：字符串中間位置增加
        int i = builder.indexOf("下");//找到字符串的數組下標
        builder.insert(i,"一棵銀杏樹");//在下標前插入新的子串
        System.out.println(builder.length()+"\t"+ builder.capacity());//24 38
 
 
        //操作：字符串修改
        int i2 = builder.indexOf("銀杏樹");//找到字符串的數組下標
        builder.replace(i2,i2+3,"芒果樹");//要替換的字符串的起始位置，結束位置，要替換的字符串 ：北京故宮博物院墻角一棵芒果樹樹下的一隻懶貓在睡覺覺
 
        //操作：字符串刪除
        builder.deleteCharAt(23);//參數為要刪除的那個字符的索引下標  ：北京故宮博物院墻角一棵芒果樹下的一隻懶貓在睡覺
        builder.delete(0,7);//start並延伸到字符索引end - 1：墻角一棵芒果樹下的一隻懶貓在睡覺子串開始於指定
 
        //操作：字符串輸出
        String str = builder.toString();//將StringBuilder轉變為一個字符串
        System.out.println(str);//墻角一棵芒果樹下的一隻懶貓在睡覺
        System.out.println(builder.toString());//墻角一棵芒果樹下的一隻懶貓在睡覺
        System.out.println(builder);//墻角一棵芒果樹下的一隻懶貓在睡覺
        System.out.println(builder.reverse());//覺睡在貓懶隻一的下樹果芒棵一角墻
        System.out.println(builder);//覺睡在貓懶隻一的下樹果芒棵一角墻--->沒有創建新的字符串對象
    }
}

//1.創建對象（String-->StringBuilder） 
        StringBuilder builder = new StringBuilder("xxx");
 
//2.末尾追加字符串
        builder.append("yyy");
 
//3.轉換為字符串（StringBuilder--->String）
        String str = builder.toString()
        System.out.println(str);

StringBuilder builder = new StringBuilder();
//StringBuilder 的無參構造初始容量為：16

//創建Builder對象時，底層的數組大小實際為輸入的字符串長度個數+16
StringBuilder builder = new StringBuilder("故宮博物院");
System.out.println(builder.length()+"\t"+ builder.capacity());

String str = builder.toString();
System.out.println(str);