【Java】字符串的方法API（char、byte、查找、截取、匹配规则、替换、拆分相关）

字符串的API

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);//[B@23fe1d71
		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

转载：https://blog.csdn.net/qq_41569732/article/details/106307562