String字符串类、正则表达式以及Pattern类

本文介绍了Java中的String字符串，包括其不可变性及常用方法。然后详细讲解了可变字符串StringBuilder，包括创建、基本使用及扩容机制。接着探讨了正则表达式的应用，特别是在String中的matches方法，以及Pattern类的使用，如find、group等方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、String字符串

1、String（不可变字符串）

在这里插入图片描述
1、1创建String对象

@Test
	void test() {
	    //创建String字符串常量池
		String   str01 = "abc";
		String   str02 = "abc";
		//new实例
		String  str03  = new String("abc");
	    String  str04  = new String("abc");
	    
	    //==和equals比较
	    System.out.println(str01==str02);//true
	    System.out.println(str03==str04);//false
	    System.out.println(str01==str03);//false
	    System.out.println(str01.equals(str02));//true
	    System.out.println(str03.equals(str04));//true
	    System.out.println(str03.equals(str01));//true
	    
	    //常量池的作用
	    String  s01 = "abc";
	    String  s02 = "def";
	    String  s03 = "abcdef";
	    String  s04 = s01+s02;
	    System.out.println(s03==s04);//false
	    System.out.println(s03.equals(s04));//true
	}

1、2String的常用方法
注意：如果是对字符串进行改变操作，是得到一个新的字符串

charAt( int index);
compareTo(String anotherString);
concat(String str);
contains(CharSequence s);
contentEquals(CharSequence cs);
copyValueOf( char [ ] data);
endsWith( String suffix);
equals(Object anObject);
format（ String format,Objects…args);
getBytes();
getBytes( String charsetName);
getChars( int srcBegin,int srcEnd, char [] dst, int dstBegin);
indexOf(String str);
indexOf( String str, int fromIndex);
lastIndexOf( String str);
lastIndexOf( String str , int fromIndex );
length();
matches(String regex);
replace( char oldChar,char newChar);
split( String regex);
split( String regex,int limit);
startsWith( String prefix);
substring( int beginIndex);
substring( int beginIndex,int endIndex);
toLowerCase();
toUpperCase();
trim();
valueOf(long l);

代码演示如下：

@Test
	void test1() {
		// char数组转换为字符串
		char[] cs = new char[] { 'a', 'b', 'c', 'd' };
		String str = new String(cs);
		System.out.println(str);// abcd

		// 将字符串转换为byte数组
		String s = "好想爱这个世界啊";
		byte[] bytes = s.getBytes();
		System.out.println(bytes.length);// 24

		// 将字节数组转为字符串
		String st = new String(bytes, 0, 6);
		System.out.println(st);// 好想

	}

	@Test
	void test2() {

		String mess = "abcdefg";
		String s01 = "a";
		String s02 = "e";

		// 获取指定位置的字符，下标从零开始
		System.out.println("获取第三个字符：" + mess.charAt(2));// 获取第三个字符：c
		// 比较两个字符,比较的是自然顺序与其他位置差
		System.out.println("比较字符" + s01.compareTo(s02));// 比较字符-4
		// 字符串的拼接
		String concat = mess.concat("hello");
		System.out.println("原字符串" + mess);// 原字符串abcdefg
		System.out.println("新字符串" + concat);// 新字符串abcdefghello
		// 是否含有子字符串，模糊查询
		System.out.println("是否包含" + mess.contains("f"));// 是否包含true
		// 全比
		System.out.println("contentEquals方法" + s01.contentEquals("a"));// contentEquals方法true
	}

	@Test
	void test3() {
		char[] cs = new char[] { 'a', 'b', 'c', 'd' };
		// 转换
		System.out.println("转换结果是" + String.copyValueOf(cs));//转换结果是abcd
		/*
		 * data - 字符数组。
		 * offset - 子数组的初始偏移量。 
		 * count - 子数组的长度。 
		 */
		System.out.println("转换结果是" + String.copyValueOf(cs, 0, 2));//转换结果是ab
		
		//后缀验证
		String  email = "1112225@qq.com";
		//使用三目运算符
		System.out.println(email.endsWith("@qq.com") ? "是邮箱" : "不是邮箱");//是邮箱
		//equals字符串与任意对象进行比较
		String  num = "123456";
		System.out.println("equals的比较"+num.equals("123456"));//equals的比较true
	}
	
	
	@Test
	void test4() {
		//字符串转换为字节数组
		String  ms = "你好";
		byte[] bytes = ms.getBytes();
		for (byte b : bytes) {
			System.out.print(b);
			System.out.println("===");
		}
		
		//使用指定编码进行转换，用什么编码进行解析，就用什么编码进行读取
		try {
			//使用UTF-8编码对该字符串进行转换
			byte[] bytes2 = ms.getBytes("UTF-8");
			
			//将字节数组转为字符串
			String  str = new String(bytes2,"UTF-8");
			System.out.println(str);//你好
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Test
	void test5() {
		String  mess = "abcdefgabcddd";
		/*
		 * 将字符串中的每一个字符保存到一个已有的char数组中
		 * 第一个参数：字符串中要复制的第一个字符的索引
		 * 第二个参数：字符串中要复制的第二个字符的索引
		 * 第三个参数：目标数组
		 * 第四个数组：目标数组的起始偏移量
		 */
		char [] cs = new char[mess.length()];
		mess.getChars(2, mess.length(), cs, 0);
		for (char c : cs) {
			System.out.print(c);//cdefg 
		}
		
		
		//获取指定字符第一次出现的位置，如果有则返回下标，如果没有返回-1
		System.out.println(mess.indexOf("f"));//5
		System.out.println(mess.indexOf("d", 4));//10
		System.out.println(mess.lastIndexOf("d",17 ));//起始位置如果超过字符个数，从头开始找
	}

class StringClass01 {

	
	
	@Test
	void test() {
		
		String   mess = "helloworld";
		/*替换
		 * 第一个参数：要替换的字符串中的子字符串或者字符
		 * 第二个参数：用来替换的字符串
		 */
		String replace = mess.replace("o", "华晨宇");
		System.out.println(replace);//hell华晨宇w华晨宇rld
		/*  底层代码
		 *  public String replace(CharSequence target, CharSequence replacement) {
         *   return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
         *      this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
         *        }    
		 */
		

		//拆分
		String  mess01 = "abc123debu456nchfg789";
		//通过三个数字进行分割
		String[] split = mess01.split("\\d");
		for (String string : split) {
			System.out.println(string);
		}
		
		/*
		 * 小例子：判断电话号码的起始是不是13，15，18
		 */
		long  p =15619723782l;
		Long  pp=p;//自动装箱
		String  phone =pp.toString();
		System.out.println(phone.startsWith("13")  || phone.startsWith("15")   || phone.startsWith("18"));//true
		
	}
	
	@Test
	void test1() {
		//截取，从字符串中截取子字符串
		String  mess = "abcd123456EFg    ";
		//从下标为1的位置开始截取
		String substring = mess.substring(1);
		System.out.println(substring);//bcd123456EFg
		//前后位置都设置好,包前不包后
		String substring2 = mess.substring(1, 9);
		System.out.println(substring2);//bcd12345
		
		//从符合要求的位置到最后一个去截取
		int indexOf = mess.indexOf("123");
		String substring3 = mess.substring(indexOf);
		System.out.println(substring3);//123456EFg
		
		
		
		
		//去除前后空格，在对字符串进行比较之前，最好都去除掉空格
		System.out.println(mess.length());//17
		System.out.println(mess.trim().length());//13
		
	}
	
	
	//将数据转为String
	@Test
	void test2() {
		//基本类型
		int num = 10;
		System.out.println(String.valueOf(num));//10
		Integer  numi = num;
		System.out.println(String.valueOf(numi));//10
		System.out.println(String.valueOf(new Student()));//Student [age=0]
	}
}


class Student{
	
	int age;

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

2、StringBuffer/StringBuilder(可变字符串）

2、1介绍

StringBuffer和StringBuilder是可变字符串，是用来存储字符串的
他们两个的区别是：StringBuffer是线程安全的，但是速度慢，而StringBuilder是线程不安全的，但是速度快。在不考虑线程安全的情况下我们一般使用StringBuilder.

2、2StringBuilder的创建

使用构造方法
在这里插入图片描述

容量 = 缓冲区大小+实际存放的字符的长度
长度=容器中实际存放的字符串的字符长度

2、3StringBuilder的基本使用

append( int i);
append( long long);
append( Object obj);
append( String str);
append( StringBuilder sb);
substring( int start , int end);
replace( int start , int end, String str);
start - 起始索引（包含）。
end - 结束索引（不包含）。
str - 将替换原有内容的字符串。

具体演示见代码：

class StringBuiderClass {

	/**
	 * 以StringBuilder为例子，StringBuffer使用方式一样 默认的初始容量为16个
	 * 当StringBuilder的容量无法满足当前存入的字符串的长度，此时StringBuilder会进行自动扩充容量，扩容机制 length >
	 * capatity,先自动扩容，capatity = capatity*2+2 再次进行length>capatity,最后的容量大小capatity =
	 * length
	 */

	@Test
	void test() {
		// 创建字符串
		StringBuilder strbuff = new StringBuilder();// 默认大小的字符串
		StringBuilder strbuff01 = new StringBuilder(10);// 指定大小的字符串
		StringBuilder strbuff02 = new StringBuilder("hello");// 直接存入字符串

		// 查看容量
		System.out.println(strbuff.capacity());// 16
		System.out.println(strbuff01.capacity());// 10
		System.out.println(strbuff02.capacity());// 21
		// 查看长度，长度是具体的存放的字符的长度
		System.out.println(strbuff.length());// 0
		System.out.println(strbuff01.length());// 0
		System.out.println(strbuff02.length());// 5
	}
	
	
	//对可变字符串进行操作
	@Test
	void test1() {
		                              
		StringBuilder  strbuff = new  StringBuilder();//默认大小16capacity
		System.out.println("初始的容量大小为"+strbuff.capacity());//初始的容量大小为16
		//增加
		strbuff.append("hello");
		System.out.println("追加后的字符串长度是"+strbuff.length());//追加后的字符串长度是5
		System.out.println("追加后的字符串的容量是"+strbuff.capacity());//追加后的字符串的容量是16
		//第二次增加
		strbuff.append("1b3gh332823degyegywifw");
		System.out.println("二次追加后字符串的长度是"+strbuff.length());//二次追加后字符串的长度是27
		//放不下了  16*2+2=34；
		System.out.println("二次追加后字符串的容量是"+strbuff.capacity());//二次追加后字符串的容量是34
		
		//插入字符
		/*
		 * 第一个参数：偏移量
		 * 第二个参数：要插入的字符串
		 */
		strbuff.insert(1, "华晨宇");
		System.out.println(strbuff);//h华晨宇ello1b3gh332823degyegywifw
		
		//替换字符
		/*
		 * 第一个参数：起始位置
		 * 第二个参数：结束位置
		 * 第三个参数：要替换的字符串
		 */
		strbuff.replace(4, 29, "好想爱这个世界啊");
		System.out.println(strbuff);//h华晨宇好想爱这个世界啊w

		//删除字符   包前不包后
		strbuff.delete(0, 4);
		System.out.println(strbuff);//好想爱这个世界啊w
		strbuff.deleteCharAt(8);
		System.out.println(strbuff);//好想爱这个世界啊
		
		//反转字符串
		strbuff.reverse();
		System.out.println(strbuff);//啊界世个这爱想好
		
		
	}
	
	//如何将StringBuilder转为String
	@Test
	void test2() {
		/*三种方法
		 * 第一种：使用toString方法实例化
		 * 第二种：全部截取
		 * 第三种：String的构造方法
		 */
		
		StringBuilder  strbuff = new StringBuilder("hello");
		String  string = strbuff.toString();
		System.out.println(string);//hello
		System.out.println(string  instanceof  String);//true
		
		//全部截取
		String substring = strbuff.substring(0);
		System.out.println(substring);
		
		
		//使用String的构造方法
		String   str = new String(strbuff);
		System.out.println(str);
		
	}

}

2、4可变字符串的初始容量和扩容机制

*当StringBuilder的容量无法满足当前存入的字符串的长度，此时StringBuilder就会进行自动扩充容量，简称扩容机制，当length>capatity,先自动扩容，capatity = capatity 2+2;再次进行length > capatity,最后容量的大小capatity = length。

二、正则表达式

1、在S中使用正则表达式

在String中，matches(String regex)方法使用到了正则表达式
在这里插入图片描述
构造摘要

使用实例

//使用正则表达式去匹配
	@Test
	void test6() {
		String  str = "好好学习，天天向上abc";
		String  s01 = "a";
		String  s02 = "1";
		
		//字符串长度    用户名长度检验
		System.out.println("字符串的长度"+str.length());//字符串的长度12
		//正则表达式，使用特殊的Java能够识别的符号来规则来匹配
		System.out.println(s01.matches("abc"));//false
		//[xxx]一个字符，使用的时候是使用每一个x与s01进行比较
		System.out.println(s01.matches("[Aaa]"));//true
		//s01是不是一个小写字母a-z范围之内
		System.out.println(s01.matches("[a-z]"));//true
		//判断s02是不是一个数字
		System.out.println(s02.matches("[1-9]"));//true
		/*
		 * 同上，
		 * \d是数字  
		 * \D不是数字  
		 * \w是单词字符  
		 * \W不是单词字符
		 */
		System.out.println(s02.matches("\\d"));//true
		
		//单个字符多次出现
		String  s03 = "aaa";
		//表示0个或者1个
		System.out.println(s03.matches("[a]?"));//false
		//表示0个或者多个
		System.out.println(s03.matches("[a]*"));//true
		//表示1个或者多个
		System.out.println(s03.matches("[a]+"));//true
		
		
		//字符串中的不同字符
		String  s04 = "xbdgeygbsvvanbcsakdbsbbbbaasvwb";
		//表示s04是不是由一个或者多个小写字母组成的
		System.out.println(s04.matches("[a-z]+"));//true
		
		//使用固定个数的匹配
		String  s05 = "1234567";
		//是不是由五个数字组成的
		System.out.println(s05.matches("[0-9]{5}"));//false
		//是不是由五个到多个数字组成的
		System.out.println(s05.matches("[0-9]{5,}"));//true
		//是不是由五个到六个数字组成的
		System.out.println(s05.matches("[0-9]{5,6}"));//false
	}

2、Java中使用Pattern类

2、1简单介绍
我们使用matches(String regex)方法只能进行规则的校验但无法获取到我们匹配到的数据，该方法的底层也是pattern；
在这里插入图片描述
2.2使用pattern和matcher类操作
具体步骤：

使用Pattern定义匹配规则
进行匹配，将匹配结果保存到Matcher中，
从Matcher中获取需要的数据
方法摘要
find( );
group();
lookingAt();
matches();
reset();

pattern的具体代码演示如下所示：

public class PatternTest {
	
	
     @Test
     void  findfun() {
    	//获取该内容中的所有数字
    	String  mess = "bywgd156vcygy19bhy7cd2bhe3782";
    	//一、使用Pattern定义匹配规则
    	Pattern   pattern = Pattern.compile("[0-9]{1,4}");
    	//二、进行匹配，将匹配结果保存到Matcher中
    	Matcher matcher = pattern.matcher(mess);
    	//三、从matcher中获取需要的数据
    	boolean find = matcher.find();
    	System.out.println(find);//true
    	// 返回以前匹配的初始索引。
    	System.out.println(matcher.start());//5
    	
    	boolean find2 = matcher.find();
    	System.out.println(find2);//true
    	System.out.println(matcher.start());//13
    	
    	boolean find3 = matcher.find();
    	System.out.println(find3);//true
    	System.out.println(matcher.start());//18
    	
    	
    	//如果找不到了，我们可以重置指针
    	matcher.reset();
    	
     }
     
     
     
     @Test
     void  lookingAtfun() {
    	 //获取该内容中的所有数字
    	 String  mess = "shd12devy47bchbvf39cdhsbhh29372bh";
    	 //使用pattern定义匹配规则
    	 Pattern pattern = Pattern.compile("[0-9]{2}");
    	 //进行匹配，将匹配好的结果保存到Matcher中
    	 Matcher matcher = pattern.matcher(mess);
    	 
    	 //lookingAt将会从头开始匹配
    	 System.out.println(matcher.lookingAt());
    	 
     }
     
     
     
     //匹配之后，获取到所有符合条件的数据并进行统计
     @Test
     void  findfun2() {
    	//获取该内容中的所有数字
     	String  mess = "bywgd156vcygy19bhy7cd2bhe3782";
     	//一、使用Pattern定义匹配规则
     	Pattern   pattern = Pattern.compile("[0-9]{1,4}");
     	//二、进行匹配，将匹配结果保存到Matcher中
     	Matcher matcher = pattern.matcher(mess);
     	//三、从matcher中获取需要的数据
     	boolean find = matcher.find();
     	//group方法用来输出你刚才所找到的字符
     	String  group = matcher.group();
     	System.out.println(group);
     	
     	//循环匹配
     	int  count = 0;
     	while(matcher.find()) {
     		count++;
     		System.out.println("电话号码是"+matcher.group());
     	}
    	System.out.println("总共匹配的数据数量是"+count+"个");
     	
     }
}