字元串的API

文章目錄

字元串的API
方法序列一: 一些簡單的方法
方法系列二：和char相關
方式系列三：和byte相關，或者說和編碼與解碼相關
方法系列（4）：startsWith 字首、endsWith 字尾
方法系列（5）：和查找有關
方法系列（6）：截取
方法系列（7）：比對規則
方法系列（8）：替換
方法系列（9）：拆分
參考資料

java.lang.string String 類代表字元串。Java 程式中的所有字元串字面值（如 “abc” ）都作為此類的執行個體實作。

方法序列一: 一些簡單的方法

（1）boolean isEmpty() 是否為空字元串為空字元串傳回true，其他為false (如果 length() 為 0，則傳回 true；否則傳回 false。)

（2）int length()：傳回字元串的長度，傳回的是字元的個數。

因為String的内部（JDK1.9之前）用char[]實作，這個長度就是value數組的長度，JDK 1.9

private final byte[] value;

（3）String toLowerCase() 轉換為小寫将此 String 中的所有字元都轉換為小寫。

String toUpperCase() 轉換為大寫将此 String 中的所有字元都轉換為大寫。

Demo

@Test
	public void test1(){
		String str = "hello";
		String str2 = "";
		String str4 = new String();
		String str5 = new String("");
		System.out.println(str.isEmpty());//false
		System.out.println(str2.isEmpty());//true
		System.out.println(str4.isEmpty());//true
		System.out.println(str5.isEmpty());//true
		
		System.out.println(str.length());//5
		System.out.println(str2.length());//

		System.out.println(str.toUpperCase());//HELLO
		System.out.println(str.toUpperCase().toLowerCase());//hello

		String str3 = "WORLD";
		System.out.println(str3.toLowerCase());//world
		System.out.println("AbC".toLowerCase());//abc
	}

（4）String trim() ：去掉字元串的前後空白符

Demo

@Test
	public void test2(){
		String str = "    hello   world    ";
		System.out.println(str);//    hello   world
		str = str.trim();
		System.out.println("[" + str + "]");//[hello   world]
		String str2 = "a1 2 3 bc";
		System.out.println(str2);//a1 2 3 bc
		str2 = str2.trim();//如果沒有前導和尾部空白，則傳回此字元串。
		System.out.println(str2);//a1 2 3 bc
		String str3 = "";
		System.out.println(str3.trim());//
		String str4 = new String();
		System.out.println(str4.trim());//
		String str5 = new String();
		System.out.println(str5.trim());//
	}

（5）String concat()：拼接，等價于+

String concat(String str)将指定字元串連接配接到此字元串的結尾。

如果參數字元串的長度為 0，則傳回此 String 對象。否則，建立一個新的 String 對象，用來表示由此 String 對象表示的字元序列和參數字元串表示的字元序列連接配接而成的字元序列。

str - 連接配接到此 String 結尾的 String。

@Test
	public void test3(){
		String s1 = "hello";
		String s2 = "world";
		String s3 = s1 + s2;
		System.out.println(s3);//helloworld
		String s4 = s1.concat(s2);
		System.out.println(s4);//helloworld
		System.out.println(s3 == s4);//false
		System.out.println(s3.equals(s4));//true
	}

方法系列二：和char相關

（1）char[] toCharArray() 将此字元串轉換為一個新的字元數組。

傳回：一個新配置設定的字元數組，它的長度是此字元串的長度，它的内容被初始化為包含此字元串表示的字元序列。

@Test
    public void test01() {
        String str = "HelloWorld";

        //統計大寫字母的個數
        char[] arr = str.toCharArray();//将此字元串轉換為一個新的**字元數組**。
        System.out.println(arr.length == str.length());//true
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= 'A' && arr[i] <= 'Z') {
                count++;
            }
        }
        System.out.println("大寫字母的個數：" + count);//大寫字母的個數：2
    }

（2）char charAt(index)

傳回指定索引處的 char 值。索引範圍為從 0 到 length() - 1。第一個 char 值位于索引 0 處。

抛出： IndexOutOfBoundsException - 如果 index 參數為負或小于此字元串的長度。

@Test
    public void test02() {
//        Scanner input = new Scanner(System.in);
//        System.out.print("請輸入性别：");
//        String str = input.next();
		String str = "菜鳥中";
        char c = str.charAt(0);
        System.out.println(c);//"菜"

        String str2 = new String("我好呀");
        char s = str2.charAt(-1);//java.lang.StringIndexOutOfBoundsException: index -1,length 3
        System.out.println(s);
    }

（3）String(char[] arr)

配置設定一個新的 String，使其表示字元數組參數中目前包含的字元序列。該字元數組的内容已被複制；後續對字元數組的修改不會影響新建立的字元串。

@Test
    public void test04() {
        char[] arr = {'h', 'e', 'l', 'l', 'o'};

        String string = new String(arr);
        System.out.println(string);//hello
        arr = new char[]{'w', 'o', 'r', 'l', 'd'};
		System.out.println(arr);//world
        System.out.println(string);//hello
        System.out.println("hello".equals(string));//true

    }

（4）String(char[] arr,int offset, int count)

配置設定一個新的 String，它包含取自字元數組參數一個子數組的字元。offset 參數是子數組第一個字元的索引，count 參數指定子數組的長度。該子數組的内容已被複制；後續對字元數組的修改不會影響新建立的字元串。

arr 字元數組 offset - 初始偏移量。count - 長度。

抛出： IndexOutOfBoundsException - 如果 offset 和 count 參數索引字元超出 value 數組的範圍。

@Test
    public void test05() {
        char[] arr = {'h', 'e', 'l', 'l', 'o'};

        String string = new String(arr, 2, 3);//從[2]開始，取3個
        System.out.println(string);//llo

//		String string2 = new String(arr,-1,5);
		//java.lang.StringIndexOutOfBoundsException: offset -1, count 5, length 5
//		System.out.println(string2);
    }

方式系列三：和byte相關，或者說和編碼與解碼相關

（1）byte[] getBytes()：編碼的方法，使用平台預設的字元編碼進行編的。

byte[] getBytes(Charset charset)，使用給定的 charset 将此 String 編碼到 byte 序列，并将結果存儲到新的 byte 數組。

@Test
	public void test01() throws UnsupportedEncodingException {
		String str = "a";
		byte[] bytes = str.getBytes();
		System.out.println(Arrays.toString(bytes));//[97]
		
		String str2 = "牛菜雞";
		byte[] bytes2 = str2.getBytes("UTF-8");
		System.out.println(bytes2);//[[email protected]
		System.out.println(Arrays.toString(bytes2));//[-25, -119, -101, -24, -113, -100, -23, -72, -95]
		String str3 =new String(bytes2,"UTF-8");
		System.out.println(str3);//牛菜雞
	}
	@Test
	public void test02(){
		String str = "abc";
		byte[] bytes = str.getBytes();
		System.out.println(Arrays.toString(bytes));//[97, 98, 99]
	}

byte[] getBytes(編碼方式)：編碼：對于ASCII碼範圍内（0~127），無論用什麼編碼方式，結果都是一樣的，一個字元對應一個位元組的編碼值。對于其他的字元，編碼，結果不一定是幾個位元組，例如漢字：

UTF-8：變長的，但是大多數漢字都是3個位元組

GBK、GB2312：固定2個位元組

ISO8859-1：不支援中文，所有字元都變為1個位元組

（2）new String(位元組數組)

new String(位元組數組，編碼方式)

String(byte[] bytes)

通過使用平台的預設字元集解碼指定的 byte 數組，構造一個新的 String。

String(byte[] bytes, Charset charset)

通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。

編碼：

編碼：
把字元–>位元組的過程，編給計算機用的
解碼：
把位元組–>字元的過程，解給人看的

亂碼：

亂碼：
（1）編碼與解碼字元集不一緻
（2）缺位元組boolean isEmpty() 是否是空字元串

@Test
	public void test03() throws UnsupportedEncodingException{
		String str = "菜鳥中";
		byte[] bytes = str.getBytes();
		System.out.println(Arrays.toString(bytes));//[-24, -113, -100, -23, -72, -97, -28, -72, -83]
	
		String string = new String(bytes,"UTF-8");
		System.out.println(string);//菜鳥中
	}
	@Test
	public void test04() throws UnsupportedEncodingException{
		String str = "菜鳥中";
		byte[] bytes = str.getBytes("GBK");
		System.out.println(bytes.length);//6
		System.out.println(Arrays.toString(bytes));//[-78, -53, -60, -15, -42, -48]

		String string = new String(bytes,"GBK");
		System.out.println(string.length());//3
		System.out.println(string);//菜鳥中
	}
	@Test
	public void test05() throws UnsupportedEncodingException{
		String str = "菜鳥中";
		byte[] bytes = str.getBytes("ISO8859-1");
		System.out.println(bytes.length);//3
		System.out.println(Arrays.toString(bytes));//[63, 63, 63]
		
		String string = new String(bytes,"ISO8859-1");
		System.out.println(string.length());//3
		System.out.println(string);//???

	}

方法系列（4）：startsWith 字首、endsWith 字尾

（1）boolean startsWith(String prefix)測試此字元串是否以指定的字首開始。參數：prefix - 字首。

如果參數表示的字元序列是此字元串表示的字元序列的字首，則傳回 true；否則傳回 false。還要注意，如果參數是空字元串，或者等于此 String 對象（用 equals(Object) 方法确定），則傳回 true。

@Test
	public void test1(){
		String name = "菜雞文";
		if(name.startsWith("菜")){
			System.out.println("菜雞文是菜家的人");
		}else{
			System.out.println("菜雞文不是菜家人");
		}
		//菜雞文是菜家的人
		System.out.println(name.startsWith(""));//true
		System.out.println(name.startsWith("菜雞文"));//true
	}

（2） boolean endsWith(String suffix)測試此字元串是否以指定的字尾結束。

參數：suffix - 字尾。

傳回：如果參數表示的字元序列是此對象表示的字元序列的字尾，則傳回 true；否則傳回 false。注意，如果參數是空字元串，或者等于此 String 對象（用 equals(Object) 方法确定），則結果為 true。

@Test
	public void test3(){
		String fileName = "Hello.class";
		if(fileName.endsWith(".java")){
			System.out.println("Java的源檔案");
		}else if(fileName.endsWith(".class")){
			System.out.println("位元組碼檔案");
		}
		//位元組碼檔案
		System.out.println(fileName.endsWith(""));//true
		System.out.println(fileName.endsWith("Hello.class"));//true
	}

方法系列（5）：和查找有關

（1）是否包含

boolean contains(CharSequence s)

當且僅當此字元串包含指定的 char 值序列時，傳回 true。

參數：

s - 要搜尋的序列

傳回：

如果此字元串包含 s，則傳回 true，否則傳回 false

抛出：

NullPointerException - 如果 s 為 null

@Test
	public void test01(){
		String str = "123.45";
		
		if(str.contains(".")){
			System.out.println("是小數");
		}
		System.out.println(str.contains(""));//true
		System.out.println(str.contains("12345"));//false
		System.out.println(str.contains("123"));//true
		System.out.println(str.contains("54"));//false
//		System.out.println(str.contains(null));//java.lang.NullPointerException
	}

（2）int indexOf(int ch)、index indexOf(String str):如果存在傳回下标，如果不存在傳回-1

在此對象表示的字元序列中第一次出現該字元的索引；如果未出現該字元，則傳回 -1。

如果在此 String 對象表示的字元序列中出現值為 ch 的字元，則傳回第一次出現該字元的索引（以 Unicode 代碼單元表示）。

@Test
	public void test02(){
		String str = "123.45";
//		String str = "123";
		int index = str.indexOf(".");
		System.out.println(index);//3
		int index2 = str.indexOf("12");//0
		System.out.println(index2);
		int index3 = str.indexOf("54");
		System.out.println(index3);//-1
		int index4 = str.indexOf("A");
		System.out.println(index4);//-1
		int index5 = str.indexOf(0);
		System.out.println(index5);//-1
		int index6 = str.indexOf('1');
		System.out.println(index6);//0
		int index7 = str.indexOf('5');
		System.out.println(index7);//5

	}

int indexOf(int ch,int fromIndex)、int indexOf(String str,int fromIndex)傳回在此字元串中第一次出現指定字元處的索引，從指定的索引開始搜尋。

參數：

ch - 一個字元（Unicode 代碼點）。

fromIndex - 開始搜尋的索引。

傳回：

在此對象表示的字元序列中第一次出現的大于或等于 fromIndex 的字元的索引；如果未出現該字元，則傳回 -1。

@Test
	public void test04(){
		String str = "123.45";
//		String str = "123";
		int index = str.indexOf(".");
		System.out.println(index);//3
		int index2 = str.indexOf(".",3);
		System.out.println(index2);//3
		int index3 = str.indexOf(".",4);
		System.out.println(index3);//-1
		int index4 = str.indexOf(1,0);
		System.out.println(index4);//-1
		int index5 = str.indexOf('1',0);
		System.out.println(index5);//0
	}

（3）int lastIndexOf(xx)：如果存在傳回最後一個的下标，如果不存在傳回-1

在此對象表示的字元序列中最後一次出現該字元的索引；如果未出現該字元，則傳回 -1。

int lastIndexOf(xxx,int fromIndex) 在此對象表示的字元序列（小于等于 fromIndex）中最後一次出現該字元的索引；如果在該點之前未出現該字元，則傳回 -1。

@Test
	public void test03(){
		String fileName = "Hello.java.txt";
		//檔案的字尾名是什麼
		//截取檔案的字尾名
		//(1)第一步，找到最後一個.的位置
		int index = fileName.lastIndexOf(".");
		System.out.println(index);//10
	}

方法系列（6）：截取

(1)String substring(int beginIndex)：從字元串的[beginIndex]截取到最後

傳回一個新的字元串，它是此字元串的一個子字元串。該子字元串從指定索引處的字元開始，直到此字元串末尾。

參數：

beginIndex - 起始索引（包括）。

傳回：

指定的子字元串。

抛出：

IndexOutOfBoundsException - 如果 beginIndex 為負或大于此 String 對象的長度。

(2)String substring(int beginIndex, int endIndex)：截取字元串的[beginIndex,endIndex)部分

傳回一個新字元串，它是此字元串的一個子字元串。該子字元串從指定的 beginIndex 處開始，直到索引 endIndex - 1 處的字元。是以，該子字元串的長度為 endIndex-beginIndex。

參數：

beginIndex - 起始索引（包括）。

endIndex - 結束索引（不包括）。

傳回：

指定的子字元串。

抛出：

IndexOutOfBoundsException - 如果 beginIndex 為負，或 endIndex 大于此 String 對象的長度，或 beginIndex 大于 endIndex。

@Test
	public void test03(){
		String fileName = "Hello.java.txt";
		//檔案的字尾名是什麼  .txt 
		//截取檔案的字尾名
		//(1)第一步，找到最後一個.的位置
		int index = fileName.lastIndexOf(".");

		//(2)截取
		String sub = fileName.substring(index);
		System.out.println(sub);
	}

@Test
	public void test04(){
		String str = "helloworldjava";
		String sub = str.substring(2, 6);
		System.out.println(sub);//llow
		String str2 = "你好呀最近怎麼樣呢";
		String sub2 = str2.substring(1,3);
		System.out.println(sub2);//好呀
	}

方法系列（7）：比對規則

boolean matches(正規表達式)

告知此字元串是否比對給定的正規表達式。

參數：

regex - 用來比對此字元串的正規表達式

傳回：

當且僅當此字元串比對給定的正規表達式時，傳回 true

抛出：

PatternSyntaxException - 如果正規表達式的文法無效
正規表達式：用于檢測文本的格式
校驗某個字元串是否符合xx規則
例如：電話号碼
甚至可以校驗是否是移動号…
銀行卡号
郵箱格式
…

@Test
	public void test1(){
		String str = "123456789";
		
		//判斷它是否全部由數字組成，并且第1位不能是0，長度為9位
		//第一位不能是0，那麼數字[1-9]
		//接下來8位的數字，那麼[0-9]{8}+
		boolean flag = str.matches("[1-9][0-9]{8}+");
		System.out.println(flag);//true
	}

@Test
	public void test2(){
		String str = "12a345";
		//簡單判斷是否全部是數字，這個數字可以是1~n位
		
		//正則不是Java的文法，它是獨立與Java的規則
		//在正則中\是表示轉義，
		//同時在Java中\也是轉義
		boolean flag = str.matches("\\d+");
		System.out.println(flag);//false
	}

方法系列（8）：替換

方法系列（8）：替換
（1）String replace(target, replacement)

使用指定的字面值替換序列替換此字元串所有比對字面值目标序列的子字元串。該替換從字元串的開頭朝末尾執行，例如，用 “b” 替換字元串 “aaa” 中的 “aa” 将生成 “ba” 而不是 “ab”。

參數：

target - 要被替換的 char 值序列

replacement - char 值的替換序列

傳回：

所得 String

抛出：

NullPointerException - 如果 target 或 replacement 為 null。

（2）String replaceAll(String regex, String replacement)

使用給定的 replacement 替換此字元串比對給定的正規表達式的第一個子字元串。

（3）String replaceFirst(String regex, String replacement)

使用給定的 replacement 替換此字元串所有比對給定的正規表達式的子字元串。

參數：

regex - 用來比對此字元串的正規表達式

replacement - 用來替換每個比對項的字元串

傳回：

所得 String

抛出：

PatternSyntaxException - 如果正規表達式的文法無效

其中（2）和（3）支援正則

replace

@Test
	public void test1(){
		String str = "飛出個未來，計算靈光點。";
		str = str.replace("未來", "**");
		System.out.println(str);//飛出個**，計算靈光點。
	}

replaceFirst

@Test
	public void test2(){
		String str = "飛出個未來，計算靈光點，碼出個未來。";
		str = str.replaceFirst("未來", "***");
		System.out.println(str);
	}

replaceAll

@Test
	public void test3(){
		String str = "飛出個未來，計算靈光點，碼出個未來。";
		str = str.replaceAll("未來", "***");
		System.out.println(str);//飛出個***，計算靈光點，碼出個***。
	}

replaceAll("[^a-zA-Z]", “”)

@Test
	public void test4(){
		String str = "ABC碼出個未來abc;123";
		//把其中的非字母去掉
		str = str.replaceAll("[^a-zA-Z]", "");
		System.out.println(str);
	}

方法系列（9）：拆分

String[] split(xx)

根據給定正規表達式的比對拆分此字元串。

參數：

regex - 定界正規表達式

傳回：

字元串數組，它是根據給定正規表達式的比對拆分此字元串确定的

抛出：

PatternSyntaxException - 如果正規表達式的文法無效

@Test
	public void test1(){
		String str = "Hello World java 菜雞 菜牛";
		String[] all = str.split(" ");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
		//Hello
		//World
		//java
		//菜雞
		//菜牛
	}

@Test
	public void test2(){
		String str = "1Hello2World3java4菜雞";
		str = str.replaceFirst("\\d", "");
		System.out.println(str);
		String[] all = str.split("\\d");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
		//Hello2World3java4菜雞
		//Hello
		//World
		//java
		//菜雞
	}

@Test
	public void test3(){
		String str = "1Hello2World3java4菜雞5";
		str = str.replaceAll("^\\d|\\d$", "");
		String[] all = str.split("\\d");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
		//Hello
		//World
		//java
		//菜雞
	}

/*
 * 方法系列（9）：拆分
 * String[] split(xx)
 */
public class TestMethod9 {
    @Test
    public void test4() {
        String str = "張三.23|李四.24|王五.25";
        //|在正則中是有特殊意義，我這裡要把它當做普通的|
        String[] all = str.split("\\|");

        //轉成一個一個學生對象
        Student[] students = new Student[all.length];
        for (int i = 0; i < students.length; i++) {
            //.在正則中是特殊意義，我這裡想要表示普通的.
            String[] strings = all[i].split("\\.");//張三,  23
            String name = strings[0];
            int age = Integer.parseInt(strings[1]);
            students[i] = new Student(name, age);
        }

        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
        //Student [name=張三, age=23]
        //Student [name=李四, age=24]
        //Student [name=王五, age=25]

    }

    @Test
    public void test3() {
        String str = "1Hello2World3java4菜雞5";
        str = str.replaceAll("^\\d|\\d$", "");
        String[] all = str.split("\\d");
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
        //Hello
        //World
        //java
        //菜雞
    }

    @Test
    public void test2() {
        String str = "1Hello2World3java4菜雞";
        str = str.replaceFirst("\\d", "");
        System.out.println(str);
        String[] all = str.split("\\d");
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
        //Hello2World3java4菜雞
        //Hello
        //World
        //java
        //菜雞
    }


    @Test
    public void test1() {
        String str = "Hello World java 菜雞 菜牛";
        String[] all = str.split(" ");
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
        //Hello
        //World
        //java
        //菜雞
        //菜牛
    }
}

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Student() {
        super();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

參考資料

記錄 - 搞定Java核心技術

高薪之路–Java面試題精選集

從Hello到goodbye

字元串的API

文章目錄

方法序列一: 一些簡單的方法

方法系列二：和char相關

方式系列三：和byte相關，或者說和編碼與解碼相關

方法系列（4）：startsWith 字首、endsWith 字尾

方法系列（5）：和查找有關

方法系列（6）：截取

方法系列（7）：比對規則

方法系列（8）：替換

方法系列（9）：拆分

參考資料

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

GridView終極用法(一)

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method