第十章 字符串
目录
10.1 String类
10.1.1 声明字符串
10.1.2 创建字符串
1.String(char a[])
2.String(char a[], int offset, int length)
3.String(char[] value)
10.2 连接字符串
10.2.1 连接多个字符串
10.2.2 连接其他数据类型
10.3 获取字符串信息
10.3.1 获取字符串长度
10.3.2 字符串查找
1、indexOf(String s)
2、lastIndexOf(String str)
10.3.3 获取指定索引位置的字符
10.4 字符串操作
10.4.1 获取子字符串
1.substring(int beginIndex)
2. substring(int beginlndex, int endlndex)
10.4.2 去除空格
10.4.3 字符串替换
10.4.4 判断字符串的开始与结尾
1、startsWith()方法
2、endsWith()方法
10.4.5 判断字符串是否相等
1.equals()方法
2.equalsIgnoreCase()方法
10.4.6 按字典顺序比较两个字符串
10.4.7 字母大小写转换
1.toLowerCase()方法
2.toUpperCase()方法
10.4.8 字符串分割
1、split(String sign)
2、split(String sign,int limit)
10.5 格式化字符串
1、format(String format,Object...args)
2、format(Local l,String format,Object...args)
10.5.1 日期和时间字符串格式化
1、日期格式化
2、时间格式化
3、格式化常见的日期时间组合
10.5.2 常规类型格式化
10.6 使用正规表达式
10.7 字符串生成器
1、append()方法
2、insert(int offset,arg)方法
3、delete(int start, int end)方法
10.1 String类
单个字符可以用char类型保存，多个字符组成的文本就需要保存在String对象中。String通常被称为字符串，一个String对象最多可以保存(
-1)个字节（占用4GB空间大小）的文本内容。
10.1.1 声明字符串
在Java语言中，字符出啊必须包含在一对双引号(" ")之内。例如：
“23.23”、“ABCDE”、“你好”
以上这些都是字符串常量，字符串常量可以是系统能够显示的任何文字信息，甚至可以是单个字符。
可以通过以下语法格式来声明字符串变量：
String str;
- String：指定该变量为字符串类型
- str：任意有效的标识符，表示字符串变量的名称
声明字符串变量s，代码如下：
String s;
10.1.2 创建字符串
在Java 语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象创建对象要使用类的构造方法。String 类的常用构造方法如下。
1.String(char a[])
该方法用一个字符数组a创建 String 对象，代码如下:
char a[ ] = {'g','o','o','d'};
String s = new String(a);等价于 String s = new String("good")
2.String(char a[], int offset, int length)
该方法提取字符数组 a 中的一部分创建一个字符串对象。参数 ofset 表示开始截取字符串的位置length 表示截取字符串的长度。代码如下:
char a[] ={ 's','t','u','d','e','n','t'};
String s = new String(a,2,4);等价于 String s = new String("uden");
3.String(char[] value)
该构造方法可分配一个新的 String 对象，使其表示字符数组参数中所有元素连接的结果。代码如下:
char a[]={'s','t','u','d','e','n','t'};
String s = new String(a);等价于 String s = new String("student");
public class Test1 {
public static void main(String[] args) {
//字符串变量的声明
String s;
//字符串变量初始化(第八行和第九行代码是一样的)
// s ="你好";
s =new String("你好");
System.out.println(s);
//字符串变量初始化 传入字符类型数组
char[] ch = {'g','o','o','d'};
String st = new String(ch);
System.out.println(st);
//字符串变量初始化 传入字符类型数组,两个数字(第一个数字是初始索引号，第二个数字是个数)
char[] cha = {'s','t','u','d','e','n','t'};
String str = new String(cha,2,4);
System.out.println(str);
}
}
运行结果：
10.2 连接字符串
对于已声明的字符串，可以对其进行相应的操作，连接字符串就是字符操作中较简单的一种。可以对多个字符进行连接，也可使字符串与其他数据类型进行连接。
10.2.1 连接多个字符串
使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。
public class Join { //创建类
public static void main(String[] args) {//主方法
String s1=new String ("春色绿千里");//声明string对象s1
String s2=new String ("马蹄香万家");//声明string对象s2
String s=s1+"\n"+s2; //将对象s1，"\n"和对象s2连接并将结果赋值给s
System.out.println(s); //将s输出
}
}运行结果：
10.2.2 连接其他数据类型
字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型数据进行连接，会将其他数据类型的数据直接转换成字符串。
public class Link {
public static void main(String[] args) {
int booktime =4; //声明的int型变量booktime
float practice =2.5f; //声明的float型变量practice
//将字符串与整型、浮点型变量相连接 ，并将结果输出
System.out.println("我每天花费"+booktime+"小时看书;"
+practice+"小时上机练习");
}
}
运行结果：
案例实现的是将字符串常量与整型变量booktime和浮点型变量practice相连后的结果输出。在这里booktime和practice都不是字符串，当它们与字符串相连时会自动调用tostring（）方法并转换成字符串形式，然后参与字符串连接。
如果将上例中的输出语句修改为：
System.out.println("我每天花费"+booktime+"小时看书;"+(practice+booktime)+"小时上机练习");
修改后的运行结果：
这是由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。
10.3 获取字符串信息
字符串作为对象，可通过相应方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符等。
10.3.1 获取字符串长度
使用Sting 类的length0方法可获取声明的字符串对象的长度。语法如下：
str.length();
其中，str为字符串对象。
获取字符串长度，代码如下：
String str = "We are students";
int size = str.length();
上段代码是将字符串 sr 的长度值给 in 型变量 size，此时变量 size 的值为 15，这表示 ngth方法返回的字符串的长度(包括字符串中的空格)。
10.3.2 字符串查找
String类提供了两种查找字符串的方法，即 indexf0与 lastIndexOf0方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。
1、indexOf(String s)
该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用 String 类的indexOfr方法时，会从当前字符串的开始位置搜索 s 的位置。如果没有检索到字符串 s，该方法的返回值是-1.语法如下:
indexOf(substr)
- str：任意字符串对象
- substr：要搜索的字符串
查找字符a 在字符串 str 中的索引位置，代码如下:
String str = "We are students";
int size = str.indexOf("a"); //变量 size 的值是3
理解字符串的索引位置，要对字符串的下标有所了解。在 Java 语言中，String 对象是用数组表示的。字符串的下标是0~length0-1。
2、lastIndexOf(String str)
该方法用于返回指定字符中最后一次出现的索引位置。当调用 Sting 类的 lastindexOf0方法时，会从当前字符串的开始位置检索参数字符串 ，并将最后一次出现。的聚引位置运回。如果没有检索到字符巾 str，该方法返回-1。语法如下：
str.lastIndexof(substr)
- str：任意字符串对象
- substr：要搜索的字符串
public class Test2 {
public static void main(String[] args) {
//获取字符串的长度str.length()
String str = new String("helloworld");
int length = str.length();
//查找字符串里第一次出现该元素的位置a
int indexof = str.indexOf("l");
System.out.println(indexof);
//查找字符串里最后一次出现该元素的位置
int lastIndexof = str.lastIndexOf("l");
System.out.println(lastIndexof);运行结果：
10.3.3 获取指定索引位置的字符
使用 charAt0方法可将指定索引处的字符返回。语法如下:
str.charAt(int index)
- str：任意字符串。
- index：整型值，用于指定要返回字符的下标。
public class Test2 { //创建类
public static void main(String[] args) { //主方法
//获取字符串的长度str.length()
String str = new String("helloworld");
//获取指定索引号的字符
char charAt = str.charAt(5);
System.out.println(charAt); //输出
}
}
运行结果：
10.4 字符串操作
String 类中包含了很多方法，允许程序员对字符串进行操作来满足实际编程中的需要。
10.4.1 获取子字符串
通过String类的substring0方法可对字符串进行截取。substring0方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。
1.substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下.:
str.substring(int beginlndex)
其中，beginIndex 指定从某一索引处开始截取字符串。
2. substring(int beginlndex, int endlndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下:
substring(int beginindex, int endindex)
- beginIndex:开始截取子字符串的索引位置。
- endIndex:子字符串在整个字符串中的结束位置。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//10.4字符串操作
String str = new String("helloworld"); //定义的字符串
//获取子串substring(前索引)
String substring1 = str.substring(3); //对字符串进行截取
System.out.println(substring1); //输出截取后的字符串
//获取子串substring(前索引，后索引)前含后不含
String substring2 = str.substring(3,5); //对字符串进行截取
System.out.println(substring2); //输出截取后的字符串
}
}
运行结果：
10.4.2 去除空格
trim0方法返回字符串的副本，忽略前导空格和尾部空格。语法如下:
str.trim()
其中，str 为任意字符串对象。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//例题10.4字符串操作
//去除首尾空格
String st = " java class "; //定义字符串str
System.out.println(st + "长度为：" + st.length());//将str原来的长度输出
String s = st.trim(); //定义字符串str
System.out.println(s +"长度为：" +s.length()); //将str原来的长度输出
}
}
运行结果：
10.4.3 字符串替换
replace0方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下:
str.replace(CharSequence target, CharSequence replacement)
- target:要替换的字符或字符串。
- replacement:用于替换原来字符串的内容。
replace0方法返回的结果是一个新的字符串。如果字符或字符串 oldChar 没有出现在该对象表达式中的字符串序列中，则将原字符串返回。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//字符串的替换
String stri = "address"; //定义字符串stri
String replace = stri.replace("a","A"); //将stri中“a"替换成”A“并返回新字符串replace
System.out.println(replace); //将字符串replace输出
}
}
运行结果：
10.4.4 判断字符串的开始与结尾
startsWit()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为 boolean类型。
1、startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
str.startsWith(String prefix)
其中，prefix是指作为前缀的字符串。
2、endsWith()方法
该方法用于判断当前字符串是否为以给定的子字符串结束。语法如下：
str.endsWith(String suffix)
其中，suffix是指作为后缀的字符串。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//例题10.4字符串操作
//判断字符串开头
String num1 ="45677888"; //定义字符串num1
boolean b1 = num1.startsWith("45"); //判断字符串num1是否以“45”开头
System.out.println(b1); //输出信息
//判断字符串结尾
String num2 ="45677888"; //定义字符串num2
boolean b2 = num2.endsWith("88"); //判断字符串num2是否以“88”结尾
System.out.println(b2); //输出信息
}
}
运行结果：
10.4.5 判断字符串是否相等
对字符事对象进行比较不能前单地使用比较运拿符“==”因为比较运算符比较的是两个字符中的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串。代码如下:
String tom = new String("I am a student");
String jerry = new String("I am a student");
boolean b = (tom == jerry);
此时，布东型交量b的值为flse，因为字符串是对象，tom、jcny是引用。因此，要比较两个字符串内容是否相等，应使用 equals0方法和cqualslgnorcCase()方法。
1.equals()方法
如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。语法如下：
str.equals(String otherstr)
其中，str、othersr是要比较的两个字符串对象。
2.equalsIgnoreCase()方法
使用equals()方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略大小写的情况下比较两个字符串是否相等，返回结果仍为 boolean 类型。语法如下:
str.equalslgnoreCase(String otherstr)
其中，str、otherstr 是要比较的两个字符串对象。
通过下面的例子可以看出equals()方法和 qualsIgnoreCase()方法的区别。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//判断字符串是否相等
String str1 = new String("abc"); //创建字符串对象s1
String str2 = new String("abc"); //创建字符串对象s2
boolean b = (str1 == str2); //使用equals()方法比较s1与s2
System.out.println(b); //输出信息
boolean equals = str1.equals(str2);
System.out.println(equals);
String str3 =new String("ABC"); //创建字符串对象s3
boolean equalsIgnoreCase = str1.equalsIgnoreCase(str3); //使用equalsIgnoreCase()方法比较s3
System.out.println(equalsIgnoreCase); //输出信息
}
}
运行结果：
10.4.6 按字典顺序比较两个字符串
compareTo()方法为按字典顺序比较两个字符串,该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String对象位于参数字符串之前，则比较结果为一个负整数;如果字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数:如果这两个字符串相等，则结果为0。语法如下：
str.compareTo(String otherstr)
其中，str、otherstr 是要比较的两个字符串对象。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
//按照Unicode值去比较两个字符串的顺序
//用于比较的三个字符串
String st1 = "a";
String st2 = "b";
String st3 = "c";
System.out.println(st1.compareTo(st2));//将st1与st2比较的结果输出
System.out.println(st2.compareTo(st2));//将st2与st2比较的结果输出
System.out.println(st3.compareTo(st2));//将st3与st2比较的结果输出
}
}运行结果：
10.4.7 字母大小写转换
String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改写为大写字母。
1.toLowerCase()方法
该方法将字符串中的所有大写字母转换为小写。如果字符串轴没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转化为小写，字符串长度不变。语法如下:
sir.toLowerCase()
其中，str是要进行转换的字符串。
2.toUpperCase()方法
该方法将字符串中所有的小写字母转化为大写。如果字符串中没有应该被转化的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转化成大写，字符串长度不变。语法如下：
str.toUpperCase()
其中，str是要进行转换的字符串。
public class Test3 { //创建类
public static void main(String[] args) { //主方法
String s1 = "Oh My God"; //创建字符串s1
System.out.println(s1.toLowerCase());//使用 toLowerCase()方法实行小写转换并将转换后的结果输出
System.out.println(s1.toUpperCase());//使用 toUpperCase()方法实行大写转换并将转换后的结果输出
}
}
运行结果：
10.4.8 字符串分割
使用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: 限制的分割次数。
public class Judge { //创建类
public static void main(String[] args) { //主方法
String strin = "194.192.0.1"; //创建字符串
String[] split1 = strin.split("\\."); //按照“.”进行分割，使用转义字符“\\.”
for(String temp : split1) {
System.out.println(temp); //输出
}
String[] split2 = strin.split("\\.,2"); //按照“.”进行两次分割，使用转文字符“\\.”
for(String temp : split2) {
System.out.println(temp); //输出
}
}
}运算结果：
10.5 格式化字符串
String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
1、format(String format,Object...args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地器的语言环境。语法如下:
str.format(String format,Object...args)
- format:格式字符串。
- args:格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这额外的参数。此参数的数目是可变的，可以为0。
2、format(Local l,String format,Object...args)
该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串用其指定的语言环境。语法如下:
str.format(Local l,String format,Object...args)
- l:格式化过程中要应用的语言环境。如果1为null，则不进行本地化
- format:格式字符串。
- args:格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这额外的参数。此参数的数目是可变的，可以为 0。
10.5.1 日期和时间字符串格式化
在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要写大量的代码、经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期时间的格式化。
1、日期格式化
返回一个月中的天数，代码如下:
Date date = new Date(): //创建 Date 对象date
String s = String.format("%te",date); //通过 format()方法对 date 进行格式化
变量s的值是当前日期中的天数，如今天是 15 号，则s 的值为 15;%te 是转换符。
常用的日期格式化转换符如表所示：
import java.util.Date;//导入java.util.Date类
public class Test1{
public static void main(String args[]) {
Date date=new Date();//创建Date对象date
String year=String.format("%tY",date);//将date进行格式化
String month=String.format("%tB",date);
String day=String.format("%td",date);
System.out.println("今年是："+year+"年");//输出信息
System.out.println("现在是："+month);
System.out.println("今天是："+day+"号");
}
}运行结果：
2、时间格式化
使用format()方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等。格式化时间的转换符如表所示：
import java.util.Date;//导入java.util.Date类
public class Test1{
public static void main(String args[]) {
Date date=new Date();//创建Date对象date
String hour=String.format("%tH",date);//将date进行格式化
String minute=String.format("%tM",date);
String second=String.format("%tS",date);
System.out.println("现在是："+hour+"时"+minute+"分"+second+"秒");//输出信息
}
}运行结果：
3、格式化常见的日期时间组合
格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如表所示：
import java.util.Date;//导入java.util.Date类
public class Test4{
public static void main(String args[]) {
Date date=new Date();//创建Date对象date
String time=String.format("%tc",date);//将date进行格式化
String form=String.format("%tF",date);
System.out.println("全部的时间信息是："+time);//将格式化后的日期时间输出
System.out.println("年-月-日格式："+form);
}
}运行结果：
10.5.2 常规类型格式化
常规类型格式化可应用于任何参数类型，可通过如表所示：
public class Test4{
public static void main(String args[]) {
String str=String.format("%d",400/2);//将结果以十进制格式显示
String str2=String.format("%b",3>5);//将结果以Boolean型显示
String str3=String.format("%x",200);//将结果以十六进制格式显示
System.out.println("400的一半是"+str);
System.out.println("3>5正确吗："+str2);
System.out.println("200的十六进制数是"+str3);
}
}运行结果：
10.6 使用正规表达式
正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“ld”表示数字09中的任何一个，“d”就是元字符。正则表达式中的元字符及其意义如表所示：
在正则表达式中，可以使用方括号括起着于个字符来表示一个元字符，该元字符可代表方精号中
第任同一个字符。例如，B一“labc14"，这样字符 4、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次或多次。限定修饰符的用法如表所示：
public class Test4{
public static void main(String[] args) {
String regex="\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";//定义要匹配E-maill地址的正则表达式
String str1="aaa@";//定义要进行验证的字符串
String str2="aaaaa";
String str3="[email protected]";
if(str1.matches(regex)) {//判断字符串变量是否与正则表达式匹配
System.out.println(str1+"是一个合法的E-mail地址格式");
}
if(str2.matches(regex)) {
System.out.println(str2+"是一个合法的E-mail地址格式");
}
if(str3.matches(regex)) {
System.out.println(str3+"是一个合法的E-mail地址格式");
}
}
}运算结果：
10.7 字符串生成器
创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK新增了可变的字符序列 StringBuilder类,大大提高了频繁增加字符串的效率。
public class Test2{
public static void main(String[] args) {
String str="";//创建空字符串
long starTime=System.currentTimeMillis();//定义对字符串执行操作的起始时间
for(int i=0;i<10000;i++) {//利用for循环执行10000操作
str=str+i;//循环追加字符
}
long endTime=System.currentTimeMillis();
long time=endTime-starTime;//计算对字符串执行操作的时间
System.out.println("String消耗时间："+time);//将执行的时间输出
StringBuilder builder=new StringBuilder("");//创建字符串生成器
starTime=System.currentTimeMillis();//更新操作执行前的时间
for(int j=0;j<10000;j++) {//利用for循环进行操作
builder.append(j);//循环追加字符
}
endTime=System.currentTimeMillis();//更新操作后的时间
time=endTime-starTime;//更新追加操作执行时间
System.out.println("StringBuilder消耗时间："+time);//将操作时间输出
}
}运行结果：
1、append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:
append(content)
其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。
2、insert(int offset,arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:
insert(int offset arg)
- offset: 字符串生成器的位置。该参数必须大于等于 0，且小于等于此序列的长度。
- arg: 将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。
向字符串生成器中指定的位置添加字符，代码如下:
StringBuilder bf = new StringBuilder("hello");//创建字符生成器
bf.insert(5, "world");//添加至字符生成器的位置及内容
System.out.printin(bf.toString());//此时输出信息为 helloworld
3、delete(int start, int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1 处的字符。如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。语法如下:
delete(int start , int end)
- start;将要删除的字符串的起点位置。
- end:将要删除的字符的终点位置。
删除指定位置的子字符串，代码如下:
StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器
bf.delete(5.10);//删除的子字符串
System.out.println(bf.toString());//此时输出的信息为 Strinder