导图社区 Java字符串
- 79
- 2
- 2
- 举报
Java字符串
Java字符串知识点归纳。包括以下内容介绍： 一、String类 二、连接字符串 三、获取字符串信息 四、字符串操作 五、格式化字符串 六、使用正则表达式 七、字符串生产器
编辑于2022-08-15 17:49:09 贵州
- 微信小程序开发
微信小程序开发知识整理，系统地介绍了微信小程序开发的基础知识，帮助开发者更好地理解和掌握小程序开发的要点和流程。
- SpringFramework
SpringFramework技术的介绍,SpringFramework，通常简称为Spring，是一个开源的企业级Java应用程序框架，由Rod Johnson创建，并于2004年首次发布。Spring Framework的主要目标是简化企业级Java开发，提高开发效率和应用程序的可维护性。
- Maven
Maven的特性以及使用部署方法，Maven介绍：Maven是一款为Java项目构建管理、依赖管理的工具（软件），使用Maven可以自动化构建、测试、打包和发布项目，大大提高了开发效率和质量。
Java字符串
社区模板帮助中心，点此进入>>
- 微信小程序开发
微信小程序开发知识整理，系统地介绍了微信小程序开发的基础知识，帮助开发者更好地理解和掌握小程序开发的要点和流程。
- SpringFramework
SpringFramework技术的介绍,SpringFramework，通常简称为Spring，是一个开源的企业级Java应用程序框架，由Rod Johnson创建，并于2004年首次发布。Spring Framework的主要目标是简化企业级Java开发，提高开发效率和应用程序的可维护性。
- Maven
Maven的特性以及使用部署方法，Maven介绍：Maven是一款为Java项目构建管理、依赖管理的工具（软件），使用Maven可以自动化构建、测试、打包和发布项目，大大提高了开发效率和质量。
- 相似推荐
- 大纲
字符串
一、 String类
1. 声明字符串：在Java语言中字符串必须包含在一对双引号（“”）之内。例如：“23.23”、“ABCDE”、“你好”。这些都是字符串常量，字符串常量是系统能够显示任何文字信息，甚至是单个字符
语法：String str；（声明字符串变量必须经过初始化才能使用，否则编译器会报出变量未被初始化的错误）
在Java中“”包围的都是字符串，不能作为其他数据类型来使用
2. 创建字符串：在Java语言中将字符串作为对象来管理，因此可以像创建其他类对象一样创建字符串对象。创建对象要使用类的构造方法。
String类的常用构造方法
（1） String（char a[ ]）用一个字符数组a创建String对象
示例：
（2） String(char a[], int offset, int length)，提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。
示例：
（3） String(char[] value)，该构造方法可分配一个新的String对象，使其表示字符数组参数中所有元素连接的结果。
示例：
（4） 通过字符串常量的引用赋值给一个字符串变量
示例： String s1，s2； s1=“Student”； s2=“student1”；
二、 连接字符串
1. 使用“+”运算符可完成对多个字符串连接的功能。“+”运算符可以连接多个运算符并产生一个String对象
例：package changliang_bianliang; public class Stringadd { //创建字符串连接类 public static void main(String[] args) { String s1=new String("Hello"); //声明String对象s1 String s2=new String("Java"); System.out.println(s1+" "+s2);//输出对象s1和s2连接后的结果 } }
输出结果：Hello Java
Java中依据相连的字符串不能分开在两行中写，例： System.out.println（“I like Java”） 如果一个字符串太长，为了便于阅读，必须将这个字符串分在两行上书写，为了便于阅读，必须将这个字符串分在两行上书写则需要用“+”将两个字符串连接起来，之后在加号处换行
2. 连接其他数据类型：字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，会将这些数据直接转换成字符串。
package changliang_bianliang; //字符串连接其他数据类型示例 public class Link { public static void main(String[] args) { //声明主方法 int i=4399; //声明整形变量i float f=3.1415926f; //声明浮点型变量f System.out.println("玩小游戏就上"+i+"\n"+"π的值为:"+f); //将各类型的值连接后输出 } }
输出结果: 玩小游戏就上4399 π的值为:3.1415925
本例子实现的是将字符串常量与整形变量i和浮点型变量f相连后的结果输出。当i和f与字符串相连时会自动调用toString（）方法，将其转换成字符串形式，然后参与连接
三、 获取字符串信息
1. 字符串作为对象，可通过相应方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符等
1||| 获取字符串的长度：使用String类的length（）方法可获取声明的字符串对象的长度
语法：str.length（）； //其中str为字符串对象
实例：package changliang_bianliang; public class Test02 { public static void main(String[] args) { String str="姬霓太美，baby"; //声明字符串变量str System.out.println(str.length()); } }
输出结果：9
2||| 字符串查找：String类提供了两种查找字符串的方法，即indexOf（）与lastindexOf（）方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf（）方法返回的是搜索的字符或字符串首次出现的位置，lastindexOf（）方法返回的是搜索的字符或字符串最后一次出现的位置
（1） indexOf（String s）：该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用字符串的indexOf( )方法时，会从当前字符串的开始位置搜索s的位置，如果没有检索到字符串s，该方法返回值是-1
语法：str.indexOf(substr)
str：任意字符串对象
substr：要搜索的字符串
实例：package changliang_bianliang; public class Ex01 { public static void main(String[] args) { String str="surprise"; //声明字符串变量str System.out.println(str.indexOf("r")); //查找r首次出现的位置 } }
运行结果：2
理解字符串的索引位置，要对字符串的下标有所了解。在计算机中String对象是用数组表示的。字符串的下标是从0~length()-1
（2） lastIndexOf(String str)：该方法用于返回指定字符串最后一次出现的索引位置。当调用字符串的lastIndexOf()方法时。会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1
语法：str. lastIndexOf(substr)
实例：package changliang_bianliang; public class Ex01 { public static void main(String[] args) { String str="surprise"; //声明字符串变量str System.out.println(str.length()); //测量str的长度 System.out.println(str.lastIndexOf("")); //查找空字符最后出现的位置 } }
运行结果： 8 8
如果lastIndexOf()方法中的参数是空字符串“”，则返回的结果与调用该字符串length()方法的返回结果相同
2. 获取指定索引位置的字符：使用charAt()方法可将指定索引处的字符返回
语法：str.charAt(int index)
str：为任意字符串
index：整型值，用于指定要返回字符的下标
实例：package changliang_bianliang; public class Ref { public static void main(String[] args) { String str="你干嘛~嗨嗨~哎哟~"; System.out.println("字符串str中索引位置是5的字符为:"+str.charAt(5)); } }
输出结果：字符串str中索引位置是5的字符为:嗨
四、 字符串操作
String类中包含了很多方法，允许程序员对字符串进行操作来满足实际编程中的需要
获取子字符串：通过String类的substring()方法可对字符串进行截取。这些方法的共同点就是都是利用字符串的下标进行截取。应明确字符串下标是从0开始的。 substring()方法被两种不同的方法重载，来满足不同的需要
1. substring（int beginIndex）该方法返回的是从指定的索引位置开始截取直到该字符串的结尾的子串
语法：str.substring（int beginIndex），其中beginIndex指定从某一索引处开始截取字符串
实例： String str=“Hello Java”； String substr=str.substring（3）；//此时substr的值为lo World
2. substring（int beginIndex，int endIndex）：该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串
语法：str.substring（int beginIndex，int endIndex）
实例：package changliang_bianliang; //子字符串 public class Subs { public static void main(String[] args) { String str="Hello Java"; //定义字符串 String substr=str.substring(0, 5); //定义子字符串 System.out.println(substr);//输出截取后的字符串 } }
在字符串中，空格占用一个索引位置
去除空格：trim()方法返回字符串的副本，忽略前导空白和尾部空格
语法：str.trim（）
实例：package changliang_bianliang; //将字符变量原来的长度与去掉前导和尾部空格后的长度输出 public class Blak { public static void main(String[] args) { String str=" Java Class "; //定义字符串str System.out.println(str.trim()); } }
字符串替换：replace()方法可实现将指定的字符或字符串替换成新的字符或字符串
语法：str.replace(char oldChar,char newChar)
oldChar:要替换的字符串
newChar:用于替换原来字符串的内容
replace()方法返回的结果是一个新的字符串。如果字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回
实例：package changliang_bianliang; //将字符变量的a替换成A public class NewStr { public static void main(String[] args) { String str="address"; //定义字符串str String newstr=str.replace("a", "A"); //字符串替换 System.out.println(newstr); } }
输出结果：Address
如果要替换的字符oldstr在字符串中重复出现多次，replace()方法会将所有oldstr全部替换成newstr，例如： String str = "java project"; String newstr = str.replace("j","J"); 此时，newstr的值为：Java proJect，需要注意的是，要替换的字符oldstr的大小写要与原字符串中字符的大小写保持一致，否则不能成功的替换
判断字符串的开始与结尾：startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型
1. startsWith()：该方法用于判断当前字符串对象的前缀是否是参数指定的字符串
语法：str.startsWith(String prefix)
prefix：作为前缀的字符
语法：str.startsWith(String prefix，int tooffset)
tooffset:从哪个下标开始查找此字符串
2. endsWith()：该方法用于判断当前字符串是否是以给定的子字符串结束
语法：str.endsWith(String suffix)
suffix：作为后缀的字符串
实例：package changliang_bianliang; public class Start_or_End { public static void main(String[] args) { String str1="学习编程很不容易"; String str2="往往需要练习时长两年半"; boolean b1=str1.startsWith("学习"); //判断字符串str1是否以学习开头 boolean b2=str1.endsWith("容易"); //判断字符串str1是否以容易结尾 boolean b3=str2.startsWith("练习", 4); //判断字符串str2下标为3的地方是否以练习开始 boolean b4=str2.endsWith("两年半"); //判断字符串str2是否以两年半结尾 System.out.println(b1+"\t"+b2+"\t"+b3+"\t"+b4); } }
运行结果:true true true true
判断字符串是否相等:字符串作为对象如对其进行比较不能简单的使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，但两个对象的内存地址是不同的。使用比较运算符仍然会返回false,例如: String tom = new String("I am a student"); String jerry = new String("I am a student"); boolean b = (tom == jerry);//此时布尔型变量b的值为false，因为字符串是对象，tom、jerry是引用 因此要比较两个字符串内容是否相等，应使用equals()方法和equalsIgnoreCase()方法
1. equals():如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，则返回true
语法：str.equals(String otherstr)
str、otherstr：参加比较的两个字符串对象
2. equalsIgnoreCase()：使用equals()方法对字符串进行比较时，是区分大小写的。而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等。返回结果仍为boolean类型
语法：str.equalsIgnoreCase(String otherstr)
实例：package changliang_bianliang; public class Opinion { public static void main(String[] args) { String s1=new String("oh my god!"); //定义字符串对象S1 String s2=new String("Oh My God!"); //定义字符串对象S2 System.out.println(s1==s2); //使用比较运算符输出s1、s2字符串对象 boolean b=s1.equals(s2); //使用equals方法比较s1、s2是否同 boolean b1=s1.equalsIgnoreCase(s2);//忽略大小写对比 System.out.println("equals对比结果为:"+b+"\n"+"equalsIgnoreCase对比结果为:"+b1); } }
运行结果： false equals对比结果为:false equalsIgnoreCase对比结果为:true
按字典顺序比较两个字符串：compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值。按字典顺序将此String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0
语法：str.compareTo(String otherstr)
str、otherstr：参加比较的两个字符串对象
实例：package changliang_bianliang; //按字典顺序比较两个字符串 public class Wordbook { public static void main(String[] args) { String s1=new String("z"); String s2=new String("B"); String s3=new String("C"); //用于比较的3个字符串变量 System.out.println(s1+" 比"+s2+"结果为: "+s1.compareTo(s2)); System.out.println(s2+" 比"+s3+"结果为: "+s2.compareTo(s3)); } }
运行结果： z 比B结果为: 56 B 比C结果为: -1
字母大小写转换：字符串的toLowerCase()方法将字符串内的所有字符从大写字母改写为小写字母，页toUpperCase()方法可将字符串中的小写字母改写为大写字母
1. toLowerCase()：该方法将String转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回。否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都被转换成等价的小写字符。字符长度与原字符长度相同
语法：str.toLowerCase()
str：要进行转换的字符串
2. toUpperCase()：该方法将String转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回。否则返回一个新字符串，将原字符串中每个该进行大写转换的字符都转换成等价的大写字符。新字符长度与原字符长度相同
语法：str.toUpperCase()
str：要进行转换的字符串
实例：package changliang_bianliang; //字符串大小写转换 public class UpperandLower { public static void main(String[] args) { String s1=new String("zbc wordGE!"); //定义字符串对象s1 System.out.println(s1.toUpperCase()); //将字符串转化为大写后输出 System.out.println(s1.toLowerCase());// 将字符串对象转化为小写后输出 } }
输出结果： ZBC WORDGE! zbc wordge!
使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或非字符不受影响
字符串分割：使用split()方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了两种重载形式，分别为：
1. split(String sign)：该方法可根据给定的分隔符对字符串进行拆分
没有统一的对字符进行分割的符号。如果想定义多个分隔符。可使用符号“|”。例如“,|=”。表示分割符分别为“,”和“=”。
语法：str.split(String sign)
sign：为分割字符串的分隔符，也可以使用正则表达式
2. split(String sign,int limit)：该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数
语法：str.split(String sign,int limit)
sign：为分割字符串的分隔符，也可以使用正则表达式 limit：限制的分割次数
实例：package practice; //字符串分割 public class Division { public static void main(String[] args) { String str="192.168.100.5"; String []s=str.split("\\."); //按照.进行分割，使用转义字符\\ String []s1=str.split("\\.", 2);//按照.进行两次分割，使用转义字符\\ System.out.println("str的原值为:"+str); System.out.println("分割之后的结果为:"); for(String x:s) //利用foreach输出字符串数组 { System.out.print("["+x+"]"); } System.out.println(); //换行 System.out.println("分割两次后的结果为:"); for(String x:s1) { System.out.print("{"+x+"}"); } } }
输出结果： str的原值为:192.168.100.5 分割之后的结果为: [192][168][100][5] 分割两次后的结果为: {192}{168.100.5}
五、 格式化字符串
String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式
1. format(String format,Object…args)：该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境
语法：str.format(String format,Object…args)
format：格式字符串。 args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0
2. format(Local local,String format,Object…args)：使用指定的语言环境、格式字符串和参数返回一个格式化字符串
语法：str.format(Local local,String format,Object…args)
local：格式化过程中要应用的语言环境。如果local为null，则不进行本地化。 format：格式字符串。 args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。参数的数目是可变的，可以为0
日期格式化:在应用程序设计中，经常会需要显示时间和日期。如果想输出满意的日期时间格式，一般需要编写大量的代码经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化,例如: Date date = new Date(); //创建Date对象date String s = String.format("%te", date); //通过format()方法对date进行格式化
上述代码变量s的值是当前日期中的天数，如今天是15号，则s的值为15。“%te”是转换符，常用的日期和时间的格式转换符如右所示：
1||| %te：一个月中的某一天（1-31）
2||| %tb：指定语言环境的月份简称，例如：Feb（英文）、二月（中文）
3||| %tB：指定语言环境的月份全称
4||| %tA：指定语言环境的星期几全称
5||| %ta：指定语言环境的星期几简称
6||| %tc：包括全部日期和时间信息
7||| %tY：四位年份
8||| %tj：一年中的第几天（001-366）
9||| %tm：月份
10||| %td：一个月中的第几天（01-31）
11||| %ty：二位年份
实例:package practice; import java.util.Date; //输出当前日期信息以4位年份、月份、2位日期形式输出 public class Eval { public static void main(String[] args) { Date d=new Date(); //创建Date对象 String year=String.format("%tY", d); //格式化4位年份 String month=String.format("%tm", d); //格式化为月份 String day=String.format("%td", d); //格式化为2位日期 System.out.println("今年是:"+year+"年 "+month+"月 "+day+"日"); } }
输出结果:今年是:2022年 08月 13日
时间格式化:使用format()方法不但可完成日期的格式化，也可实现时间的格式化。时间格式化转换符要比日期转换符更多、更精确。它可以将时间格式化成时、分、秒、毫秒。格式化时间的转换符如右所示
1||| %tH：2位数字的24时制的小时（00-23）
2||| %tI：2位数字的12时制的小时（01-12）
3||| %tk：2位数字的24时制的小时（0-23）
4||| %tl：2位数字的12时制的小时(1-12)
5||| %tM：2位数字的分钟（00-59）
6||| %tS：2位数字的秒数（00-60）
7||| %tL：3位数字的毫秒数（000-999）
8||| %tN： 9位数字的微秒数(000000000-999999999)
9||| %tp：指定语言环境下上午或下午标记
10||| %tz：相对于GMT RFC 82 格式的数字时区偏移量
11||| %tZ： 时区缩写形式的字符串
12||| %ts：1970-01-01 00:00:00至现在经过的秒数
13||| %tQ：1970-01-01 00:00:00至现在经过的毫秒数
实例：package practice; import java.util.*; //将当前时间信息输出 public class GetDate { public static void main(String[] args) { Date date=new Date(); String s1=String.format("%tY", date); //年份 String s2=String.format("%tb", date); //月份 String s3=String.format("%td", date); //日 String s4=String.format("%tH", date); //小时 String s5=String.format("%tM", date); //分钟 String s6=String.format("%tS", date); //秒数 String s7=String.format("%tL", date); //毫秒数 String s8=String.format("%tN", date); //微秒数 String s9=String.format("%tp", date); //上下午标记 String s10=String.format("%tj", date); //一年中的第几天 System.out.println("今天是一年中的第:"+s10+"天 "+"今年是:"+s1+"年 "+s2+" "+s3+"日 "+ "\n现在是:"+s9+" "+s4+"时 "+s5+"秒 "+s6+"分 "+s7+"毫秒 "+s8+"微秒"); } }
输出结果： 今天是一年中的第:225天 今年是:2022年 8月 13日 现在是:下午 17时 57秒 02分 092毫秒 092000000微秒
格式化常见的日期时间组合：格式化日期与时间的转换符定义了各种格式日期字符串的方式，其中最常用的日期和时间的组合格式如右所示
1||| %tF：“年-月-日”格式（四位年份）
2||| %tD:“月/日/年”格式（二位年份）
3||| %tc：全部日期和时间信息
4||| %tr：“时：分：秒 PM(AM)”格式（12时制）
5||| %tT：“时：分：秒”格式（24时制）
6||| %tR：“时：分”格式（24时制）
实例：package practice; import java.util.*; //输出当前日期时间的全部信息 public class DateAndTIme { public static void main(String[] args) { Date date=new Date(); String s=String.format("%tc", date); //将字符串格式化，输出全部日期和时间信息 String s1=String.format("%tF", date); //输出年月日信息 System.out.println("全部日期和时间信息为："+s); System.out.println("年月日:"+s1); } }
输出结果： 全部日期和时间信息为：周一 8月 15 10:12:08 CST 2022 年月日:2022-08-15
常规类型格式化：常规类型的格式化可应用于任何参数类型，可通过如右表所示的转换符来实现
1||| %b、%B：结果被格式化为布尔类型
2||| %h、%H：结果被格式化为散列码
3||| %s、%S：结果被格式化为字符串类型
4||| %c、%C： 结果被格式化为字符类型
5||| %d： 结果被格式化为十进制整数
6||| %o：结果被格式化为八进制整数
7||| %x、%X：结果被格式化为十六进制整数
8||| %e：结果被格式化为用计算机科学记数法表示的十进制数
9||| %a：结果被格式化为带有效位数和指数的十六进制浮点值
10||| %n：结果为特定于平台的行分隔符
11||| %%：结果为字面值'%'
实例：package practice; //不同数据类型的转换 public class General { public static void main(String[] args) { String str=String.format("%d", 400/20); //将结果以十进制格式显示 String str1=String.format("%b", 7>9); //将结果以布尔型显示 String str2=String.format("%x", 200); //将结果以十六进制格式显示 String str3=String.format("%s", "Hello Java"); //字符串形式显示 String str4=String.format("%h", 987); //散列码显示 System.out.println(str+"\t"+str1+"\t"+str2+"\t"+str3+"\t"+str4); } }
运行结果：20 false c8 Hello Java 3db
六、 使用正则表达式
正则表达式通常被用于判断语句中，来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示字母0~9中任何一个，“\d”就是元字符。正则表达式中元字符写法及其意义，如右所示
1||| “.” ：代表任意一个字符
2||| “\\d”：代表0~9的任何一个数字
3||| “\\D”：代表任何一个非数字字符
4||| “\\s”：代表空白字符。如‘\t’、‘\n’
5||| “\\S”：代表非空白字符
6||| “\\w”：代表可用做标识符的字符，但不包括“$”符
7||| “\\W”：代表不可用于标识符的字符
8||| \\p{Lower}： 代表小写字母{a-z}
9||| \\p{Upper}：代表大写字母{A-Z}
10||| \\p{ASCII}：ASCII字符
11||| \\p{Alpha}：字母字符
12||| \\p{Digit}：十进制数字。即[0~9]
13||| \\p{Alnum}：数字或字母字符
14||| \\p{Punct}：标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
15||| \\p{Graph}： 可见字符：[\p{Alnum}\p{Punct}]
16||| \\p{Print}：可打印字符：[\p{Graph}\x20]
17||| \\p{Blank}：空格或制表符：[\t]
18||| \\p{Cntrl}： 控制字符：[\x00-\x1F\x7F]
在正则表达式中“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转义字符“\”。 在正则表达式中可以使用方括号括起来若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。例如reg =“[abc]4”。这样字符串“a4”、“b4”、“c4”都是和正则表达式匹配的字符串。方括号元字符还可以为其他格式。如： [^456]：代表4、5、6之外的任何字符。 [a-r]：代表a~r的任何一个。 [a-zA-Z]：可表示任意一个英文字母。 [a-e[g-z]]：代表a~e，或g~z中的任何一个字母。（并运算） [a-o&&[def]]：代表字母d、e、f。（交运算） [a-d&&[^bc]]：代表字母a、d.(差运算) 在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如“A*”，代表A可在字符串中出现0次或多次。修饰限定符的用法如右所示
1||| ？
意义：0次或1次 示例: A?
2||| *
意义：0次或多次 示例：A*
3||| +
意义：一次或多次 示例：A+
4||| {n}
意义：正好出现n次 示例：A{2}
5||| {n,}
意义：至少出现n次 示例： A{3,}
6||| {n,m}
意义：出现n次至m次 示例：A{2,6}
实例：package practice; //正则表达式 public class Judge { public static void main(String[] args) { String mail="\\w{0,}\\@\\w{0,}\\.{1}\\w{0,}"; //定义要检查的邮箱格式 String m="123456@"; String m2="123456@qq.com"; String m3="ZBC@123.com"; if(m.matches(mail)) { System.out.println(m+"是一个E-mail地址"); } if(m2.matches(mail)) { System.out.println(m2+"是一个E-mail地址"); } if(m3.matches(mail)){ System.out.println(m3+"是一个E-mail地址"); } } }
七、 字符串生成器
对于创建成功的字符串对象，它的长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复的对字符串进行修改，将极大地增加系统开销。从J2SE5.0开始就新增了可变的字符序列StringBuilder类，大大提高频繁增加字符串的效率。通过下面简单的测试就可以知道差距
实例：package practice; //测试字符串和字符串生成器操作的效率 public class Jerque { public static void main(String[] args) { String s=""; //空字符串 long startTime=System.currentTimeMillis(); //获取系统实时时间 for(int i=1;i<=100000;i++) { s=s+i; //循环追加字符串 } long endTime=System.currentTimeMillis(); long finalTime=endTime-startTime; //最终执行时间 System.out.println("String花费的时间为:"+finalTime); StringBuilder stb=new StringBuilder(""); startTime=System.currentTimeMillis(); for(int j=1;j<=100000;j++) { stb.append(j); } endTime=System.currentTimeMillis(); finalTime=endTime-startTime; System.out.println("StringBuilder花费的时间为:"+finalTime); } }
运行结果： String花费的时间为:5043 StringBuilder花费的时间为:4
通过上面的实例可以看出执行的时间差距很大。如果在程序中频繁的进行附加字符串，建议使用StringBuilder。新创建的StringBuilder对象初始容量是16个字符。可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder最后输出字符串结果。可使用toString()方法。应用StringBuilder类中的方法可动态的执行添加、删除、插入等字符串的编辑操作。该类的常用方法有：
1. append()方法：该方法用于向字符串生成器中追加内容，通过该方法的多个重载形式，可实现接受任何类型的数据。如int、boolean、char、String、double或者另一个字符串生成器等
语法：append(content)
content：表示要追加到字符串生成器中的内容。可以是任何类型的数据或者其他对象
2. intsert(int offset , arg)：该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char和boolean等基本数据类型或其他对象
offset：字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度 arg：将插入至字符串生成器的位置。该参数可以是任何的数据类型或其他对象
3. delete(int start , int end)：移除此序列的子字符串中的字符。该子字符串从指定的start处开始，一直到索引end - 1处的字符，如果不存在这种字符，则一直到序列尾部。如果start等于end，则不发生任何更改
语法：delete(int start , int end)
start：将要删除的字符串的起点位置 end：将删除字符串的终点位置
实例:package practice; //对字符串生成器进行操作 public class Append_Insert_Delete_test { public static void main(String[] args) { StringBuilder stb=new StringBuilder("Java nb!"); stb.append("yysy"); //增加 stb.insert(12, ",qs"); //插入 System.out.println(stb.toString()); stb.delete(8, 16); //删除 System.out.println(stb.toString()); } }
运行结果： Java nb!yysy,qs Java nb!