Java -- 字符串的认识与简单使用

1、String类

在Java语言中将字符串作为对象来处理，可以通过java.lang包中的String类来创建字符串对象

1.1 声明字符串

字符串必须包含在""中，可以是任何系统能够显示的文字信息，也可以是单个的字符。例如：

"23.45" "大" "1+2" "c"

在java中由双引号""包围的都是字符串，不能作为其它数据类型来使用，如"1+2"的结果不可能是3

语法格式：

String str = [null]

String:指定该变量的字符串类型
str:任意有效的标识符，表示字符串变量的名称
null:如果省略null，表示str变量是未初始化状态，保持默认值，否则表示声明的字符串的值等于null

变量必须初始化后才能使用，否则编译器会报错 – “变量未被初始化错误”

1.2 创建字符串

创建对象要使用类的构造方法
String类常用的构造方法如下：

1. String(char a[])
   用一个字符数组创建字符串对象

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		//1、用一个字符数组创建String对象
		char a[] = {'g','o','o','d'};
		String s = new String(a);
		
		//等价于
		String n = new String("good");
		
		System.out.println(s);
		System.out.println(n);
	}
}

控制台显示：

good
good

2. String(char a[],int offset,int length)
   提取字符数组中的一部分创建一个字符串对象
   offset代表开始截取字符串的位置，length代表截取字符串的长度

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		//2、提取字符数组中的一部分创建一个字符串对象
		char a[] = {'h','e','l','l','o'};
		String s = new String(a,1,3);
		
		//等价于
		String n = new String("ell");
		
		System.out.println(s);
		System.out.println(n);
	}
}

控制台显示：

ell
ell

3. String (char[] value)
   可分配一个新的字符串对象，使其表示字符数组参数中所有元素连接的结果

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		//3、可分配一个新的字符串对象，使其表示字符数组参数中所有元素连接的结果
		char a[] = {'h','e','l','l','o'};
		String s = new String(a);
		
		//等价于
		String n = new String("hello");
		
		System.out.println(s);
		System.out.println(n);
	}
}

控制台显示：

hello
hello

4. 字符串常量的引用赋值给一个字符串变量

package cn.tedu.test;
 
public class Test_String {
	public static void main(String[] args) {
		//4、字符串常量的引用赋值给一个字符串变量
		String str1,str2;
		str1 = "hello world";
		str2 = "hello world";
		
		System.out.println(str1);
		System.out.println(str2);
	}
}

控制台显示：

hello world
hello world

此时str1和str2引用相同的字符串常量，因此具有相同的实体。

2、连接字符串

可以进行多个字符串之间的连接，也可以进行字符串与其他的数据类型之间的连接

2.1 连接多个字符串

使用+进行连接多个字符串，可以连接多个运算符并产生一个String对象

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str1,str2,str3;
		str1 = "hello";//声明str1 对象
		str2 = " world";//声明str2 对象
		str3 = str1 + str2;//将1和2连接后的结果赋值给3
		System.out.println("str3是"+str3);
	}
}

控制台显示：

str3是hello world

注意：
在java中，一句相连的字符串不能分开在两行书写。
如果一个字符串太长可以分在两行书写，可以使用+连接起来

2.2 连接其他数据类型

字符串同这些数据相连，会将这些数据直接转换成字符串

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		int time = 4;
		float sport = 2.5f;
		System.out.println("我每天读书"+time+"小时，运动"+sport+"小时");
	}
}

控制台显示：

我每天读书4小时，运动2.5小时

注意：
只要+运算的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式。
比如上面案例中，time和sport都不是字符串，当他们与字符串相连时会自动调用toString()方法，将其转换成字符串形式，然后参与连接。
原因是运算符是具有优先级的。

3、获取字符串的信息

字符串作为对象，可通过相应的方法获取字符串的有效信息。

3.1 获取字符串的长度

使用String类的length()方法获取声明的字符串的长度
语法格式：

str.length();//str是字符串对象

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "HelloWorld";
		int s = str.length();
		System.out.println(s);
	}
}

控制台显示：10

3.2 字符串查找

String方法中提供了两种查找字符串得方法：

方法	结果
indexOf()	返回的是搜索的字符或字符串首次出现的位置
lastIndexOf()	返回的是搜索的字符或字符串最后一次出现的位置

1. indexOf(String a)
   该方法用于返回参数字符串a在指定字符串中首次出现的索引位置。
   当调用该方法时，会从当前字符串的开始位置搜索到a的位置，若没有检索到字符串a，返回值是-1
   语法格式：

str.indexOf(substr);

• str：任意字符串对象
• substr：要搜索的字符串

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "HelloWorld";
		int s = str.indexOf("o");
		System.out.println(s);
	}
}

控制台显示：4

在计算机中String对象是用数组表示的，字符串的下标是0~length()-1

2. lastIndexOf(String str)
   该方法是返回字符串最后一次出现的索引位置。
   当调用该方法时，会从当前字符串的开始位置检索参数str，并将最后一次出现str的索引位置返回，如果没有检索到就返回-1
   语法格式：

str.lastIndexOf(substr);

• str：任意字符串对象
• substr：要搜索的字符串

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "Hello World";//定义字符串str
		
		//将空字符串在str中的索引位置赋值给变量s
		int s = str.lastIndexOf(" ");
		
		//将变量s输出
		System.out.println("空字符在字符串中的索引位置是"+s);
		
		//将字符串的长度输出
		System.out.println("长度是"+str.length());
	}
}

控制台显示：

空字符在字符串中的索引位置是5
长度是11

3.3 获取指定位置索引的字符串

使用charAt()方法可将指定索引处的字符返回
语法格式：

str.charAt(int index);

• str：任意字符串对象
• index：整型值，指定要返回的字符的下标

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "Hello World";//定义字符串str
		char a = str.charAt(6);
		
		System.out.println("字符串str中索引位置为6的字符是："+a);
	}
}

控制台显示：

字符串str中索引位置为6的字符是：W

4、字符串操作

String 中包含了很多方法，允许程序员对字符串进行操作满足实际开发需求。

4.1 获取子字符串

通过String类的substring()方法可对字符串进行截取
都是利用字符串的下标进行截取，且明确字符串的下标是从0开始
substring()方法被两种不同的方法重载：

1. substring(int beginIndex)
   该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。

语法格式：

substring(int beginIndex);

• beginIndex：指定开始截取字符串的位置

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "Hello World";//定义字符串str
		String j = str.substring(3);//获取字符串
		
		System.out.println("截取的字符串是"+j);
	}
}

控制台显示：

截取的字符串是lo World

在字符串中，空格占用一个索引位置

2. substring(int beginIndex,endIndex)
   该方法返回的是从字符串某一位置开始截取到某一位置结束的子串

语法格式：

substring(int beginIndex,endIndex);

• beginIndex：指定开始截取字符串的位置
• endIndex：子字符串在整个字符串的结束位置

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "Hello World";//定义字符串str
		String j = str.substring(0,5);//获取字符串
		
		System.out.println("截取的字符串是"+j);
	}
}

控制台显示：

截取的字符串是Hello

4.2 去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格
语法格式：

str.trim();

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = " Hello World ";//定义字符串str
		
		System.out.println("字符串原来的长度："+str.length());
		System.out.println("去掉空格后的长度："+str.trim().length());
	}
}

控制台显示：

字符串原来的长度：13
去掉空格后的长度：11

4.3 字符串替换

replace()方法可以实现将指定的字符或字符串替换成新的字符或字符串
语法格式：

str.replace(char oldChar,char newChar)

• oldChar：要替换的字符或字符串
• newChar：用于替换原来字符串的内容

replace()方法返回的是一个字符串。如果字符串oldChar没有出现在该对象表达式中的字符串序列，则将原字符串返回

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = "helloworld";//定义字符串str
		String newstr = str.replace("w", "W");
		System.out.println("原来的字符串："+str);
		System.out.println("修改后的字符串："+newstr);
	}
}

控制台输出：

原来的字符串：helloworld
修改后的字符串：helloWorld

注意：
1、字符在字符串中出现多次时，replace()方法会将所有的oldChar替换为newChar
2、要替换的字符的大小写要与原字符串中字符的大小写保持一致

4.4 判断字符串的开始和结尾

startsWith()方法与endsWith()方法分别用用于判断字符串是否以指定的内容开始或结束。
两个方法的返回值都是boolean类型

1. startsWith(String prefix)
   用于判断当前字符串对象的前缀是否是参数指定的字符串

语法格式：

str.startsWith(String prefix);

• prefix：是指作为前缀的字符

2. endsWith(String suffix)
   用于判断当前字符串是否是以给定的子字符串结束

语法格式：

str.endsWith(String suffix);

• suffix：是指作为后缀的字符串

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String num1 = "454750409";//定义字符串num1
		String num2 = "180881402";//定义字符串num2
		
		boolean b = num1.startsWith("45");
		boolean b2 = num1.endsWith("02");
		boolean b3 = num2.startsWith("45");
		boolean b4 = num2.endsWith("02");
		
		System.out.println("b:"+b);
		System.out.println("b2:"+b2);
		System.out.println("b3:"+b3);
		System.out.println("b4:"+b4);
		
	}
}

控制台输出：

b:true
b2:false
b3:false
b4:true

4.5 判断字符串是否相等

对字符串对象比较不能简单地使用比较运算符==，因为比较运算符比较的是两个字符串的地址是否相同。
即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍会返回false。

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String a = new String("hello world");
		String b = new String("hello world");
		
		boolean c = (a == b);
		System.out.println(c);
	}
}

控制台显示：false
因为字符串是对象，a,b是引用。因此，要比较两个字符串内容是否相等，要使用equals()和equalsIgnoreCase()方法。

1. equals()方法

语法格式：

str.equals(String otherstr)

比较时区分大小写

2. equalsIgnoreCase()方法

语法格式：

str.equalsIgnoreCase(String otherstr)

使用时不用区分大小写，返回结果仍为boolean类型

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String a = new String("abc");
		String b = new String("ABC");
		String c = new String("abc");
		
		boolean m = a.equals(b);
		boolean n = a.equalsIgnoreCase(c);
		
		System.out.println(m);
		System.out.println(n);	
	}
}

控制台显示：

false
true

4.6 按字典顺序比较两个字符串

compareTo()方法将按照字典顺序比较两个字符串，比较方法基于各个字符的Unicode值，按字典顺序将此String对象表示的字符序列与参数字符串所表示的字符序列进行比较。
如果按字典顺序此String对象位于参数字符串之前，那么比较结果为一个负整数；
如果按字典顺序此String对象位于参数字符串之后，那么比较结果为一个正整数；
如果这两个字符串相等，那么结果为0。
语法格式：

str.compareTo(String otherstr)

说明：
compareTo()方法只有在equals(Object)方法返回true时才返回0

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str1 = new String("b");
		String str2 = new String("a");
		String str3 = new String("c");
		
		System.out.println(str1+" compareTo "+str2+":"+str1.compareTo(str2));
		System.out.println(str1+" compareTo "+str3+":"+str1.compareTo(str3));
	}
}

控制台显示：

b compareTo a:1
b compareTo c:-1

4.7 字母大小写转换

• toLowerCase()：将字符串中的所有字符从大写字母改成小写字母
• toUpperCase()：将字符串中的小写字母改成大写字母

1. toLowerCase()

如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都转换成等价的小写字母。
字符长度与原字符长度相同
语法格式：

str.toLowerCase()

• str是要进行转换的字符串

2. toUpperCase()

语法格式：

str.toUpperCase()

使用两个方法进行大小写转换时，数字或非字符不受影响

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = new String("abc DEF");
		
		String n1 = str.toLowerCase();
		String n2 = str.toUpperCase();
		
		System.out.println(n1);
		System.out.println(n2);
		
	}
}

控制台显示：

abc def
ABC DEF

4.8 字符串分割

split()方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。

1. split(String sign)
   可根据给定的分割符对字符串进行拆分

语法格式：

str.split(String sign)	

• sign 为分割字符串的分隔符，也可以使用正则表达式

没有统一的对字符进行分割的符号，要想定义多个分隔符，可以使用符号|
例如：,|=，表示分隔符分别为“，”和“=”

2. str.split(String sign,int limit)
   根据给定的分割符进行对字符串进行拆分，并限定拆分次数

语法格式：

str.split(String sign,int limit)

• sign 为分割字符串的分隔符，也可以使用正则表达式
• limit 限制的分割次数

package cn.tedu.test;

public class Test_String {
	public static void main(String[] args) {
		String str = new String("abc,def,hij,klm");
		
		//使用split()方法对字符串进行拆分，返回字符串数组
		String[] newstr = str.split(",");
		for (int i = 0; i < newstr.length; i++) {//使用for循环遍历字符数组
			System.out.println(newstr[i]);
		}
		//限制拆分次数，并返回字符数组
		String[] newstr2 = str.split(",",3);
		for (int j = 0; j < newstr2.length; j++) {//循环遍历字符数组
			System.out.println(newstr2[j]);//输出信息
		}
	}
}

控制台显示：

5、格式化字符串

String类的静态format()方法用于创建格式化的字符串

1. format(String format,Object…args)
   该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境
   语法格式：

str.format(String format,Object...args)

• format：格式字符串
• args：格式字符串中由格式说明符引用的参数
  如果还有格式说明符以外的参数，则忽略额外的参数。此参数的数目是可变的，可以为0

2. fromat(Local l,String format,Object…args)

• l：格式化过程中要应用的语言环境。如果l为null，则不进行本地化
• format：格式字符串
• args：格式字符串中由格式说明符引用的参数
  如果还有格式说明符以外的参数，则忽略额外的参数。此参数的数目是可变的，可以为0

5.1 日期和时间字符串格式化

format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

1. 日期格式化

package cn.tedu.test;

import java.util.Date;

public class Test_Date {
	public static void main(String[] args) {
		Date date = new Date();
		String s = String.format("%te", date);
		System.out.println(s);
		
	}
}

控制台输出：

当前日期中天数4

图：常用的日期格式化转换符

转换符	说明	示例
%te	一个月中的某一天	2
%tb	指定语言环境的月份简称	Feb（英文）、二月（中文）
%tB	指定语言环境的月份全称	February（二月）、二月（中文）
%tA	指定语言环境的星期几全称	Monday（英文）、周一（中文）
%ta	指定语言环境的星期几全称	Mon（英文）、周一（中文）
%tc	包括全部日期和时间信息	星期六 四月 4 15：56：32 CST 2020
%tY	4位年份	2020
%tj	一年中的第几天（0-366）	100
%tm	月份	04
%td	一个月中的第几天	4
%ty	2位年份	20

package cn.tedu.test;

import java.util.Date;

public class Test_Date {
	public static void main(String[] args) {
		Date date = new Date();
		String year = String.format("%tY", date);
		String month = String.format("%tB", date);
		String day = String.format("%td", date);
		
		System.out.println("今年是"+year+"年，"+month+"，"+day+"天");
 		
	}
}

控制台显示：

今年是2020年，四月，04天

2. 时间格式化

图：时间格式化转换符

转换符	说明	示例
%tH	2位数字的24时制得小时（00-23）	14
%tI	2位数字的12时制得小时（01-12）	05
%tk	2位数字的24时制得小时（0-23）	5
%tl	2位数字的12时制得小时（1-12）	10
%tM	2位数字的分钟（00-59）	23
%tS	2位数字的秒数（00-60）	45
%tL	3位数字的毫秒数（000-999）	560
%tN	9位数字的微妙数	063000000
%tp	指定语言环境下上午或下午标记	下午（中文）、pm（英文）
%tz	相对于GMT RFC 82格式的数字时区偏移量	+0700
%tZ	时区缩写形式的字符串	CST
%ts	1970-01-01 00:00:00至现在经过的秒数	1585988032
%tQ	1970-01-01 00:00:00至现在经过的毫秒数	1585988074081

package cn.tedu.test;

import java.util.Date;

public class Test_Date {
	public static void main(String[] args) {
		Date date = new Date();
		String h = String.format("%tH", date);
		String m = String.format("%tM", date);
		String s = String.format("%tS", date);
		
		System.out.println("现在是"+h+"时，"+m+"分，"+s+"秒");
 		
	}
}

控制台显示：

今年是16时，15分，58秒

3. 格式化常见的日期时间组合
   图：常见的日期和时间的组合方式

转换符	说明	示例
%tF	“年-月-日”格式（4位年份）	2020-04-04
%tD	“月/日/年”格式（2位年份）	04/04/20
%tc	全部日期和时间信息	星期四 四月 04 16:20:00 CST 2020
%tr	“时：分：秒PM（AM）”格式（12 时制）	04:21:36 下午
%tT	“时：分：秒”格式（24 时制）	16:23:36
%tR	“时：分”格式（24时制）	16:24

package cn.tedu.test;

import java.util.Date;

public class Test_Date {
	public static void main(String[] args) {
		Date date = new Date();
		String h = String.format("%tc", date);
		String m = String.format("%tF", date);
		
		System.out.println("全部的时间信息是："+h);
		System.out.println("年-月-日格式是："+m);
 		
	}
}

控制台显示：

全部的时间信息是：星期六 四月 04 16:25:25 CST 2020
年-月-日格式是：2020-04-04

5.2 常规类型格式化

图：常规转换符

转换符	说明	示例
%b、%B	结果被格式化为布尔类型	true
%h、%H	结果被格式化为散列码	A05A5198
%s、%S	结果被格式化为字符串类型	"abc
%c、%C	结果被格式化为字符类型	‘a’
%d	结果被格式化为十进制整数	40
%o	结果被格式化为八进制整数	11
%x、%X	结果被格式化为十六进制整数	4b1
%e	结果被格式化为用科学计算法表示的十进制数	1.700000e+01
%a	结果被格式化为带有效位数和指数的十六进制浮点数	0X1.C0000000001P4
%n	结果为特定于平台的行分隔符
%%	结果为字面值’%’	%

package cn.tedu.test;

import java.util.Date;

public class Test_Date {
	public static void main(String[] args) {
		String string = String.format("%d", 200/2);
		String string2 = String.format("%b", 3 > 5);
		String string3 = String.format("%x", 200);
		
		System.out.println(string);
		System.out.println(string2);
		System.out.println(string3);
 		
	}
}

控制台显示：

100
false
c8

6、正则表达式

通常被用于判断语句中，用来检查一字符串是否满足某一格式。
正则表达式是一些含有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。

图：正则表达式中的元字符

元字符	正则表达式中的写法	意义
.	.	代表任何一个字符
\d	\\d	代表0-9的任何一个数字
\D	\\D	代表任何一个非数字字符
\s	\\s	代表空白字符，如：‘\n’
\S	\\S	代表非空白字符
\w	\\w	代表可用作标识符的字符，但不包括“$”
\W	\\W	代表不可用于标识符的字符
…	…	…

说明：
在正则表达式中.可以表示任何一个字符，因此要在正则表达式中如果要使用普通意义的点字符，必须使用转义字符\

在正则表达式中可以使用方括号[]括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。如：

• [^456]：代表4、5、6之外的任何字符
• [a-r]：代表a~r中的任意一个字母
• [a-zA-Z]：可表示任意一个英文字母
• [a-e[g-z]]：代表a-e或e-z中的任何一个字母（并运算）
• [a-o&&[def]]：代表字母d、e、f（交运算）
• [a-d&&[^ef]]：代表字母a、d（差运算）

在正则表达式中可以允许使用限定修饰符来限定元字符出现的次数。

图：限定修饰符

限定修饰符	意义	示例
?	0次或1次	A?
*	0次或多次	A*
+	一次或多次	A+
{n}	正好出现n次	A{2}
{n,}	至少出现n次	A{3,}
{n,m}	出现n-m次	A{2,4}

package cn.tedu.test;

public class Test_Email {

	public static void main(String[] args) {
		//定义要匹配Email地址的正则表达式
		String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";
		String string = "aaa@";
		String string2 = "aaaaa";
		String string3 = "1111@111ffgh.efd.com";
		if (string.matches(regex)) {//判断字符串变量是否与正则表达式匹配
			System.out.println(string + "是一个合法的Email地址格式");
		}
		if (string2.matches(regex)) {//判断字符串变量是否与正则表达式匹配
			System.out.println(string2 + "是一个合法的Email地址格式");
		}
		if (string3.matches(regex)) {//判断字符串变量是否与正则表达式匹配
			System.out.println(string3 + "是一个合法的Email地址格式");
		}
	}
}

控制台显示：

1111@111ffgh.efd.com是一个合法的Email地址格式

7、字符串生成器

成功创建字符串对象，其长度是固定的，内容不能被改变和编译。虽然可用+拼接字符串，但会产生新的String实例，会创建新的字符串对象。如果重复的对字符串进行修改，将会极大的增加系统开销。
而J2SE 5.0新增了可变的字符序列String-Builder类，大大的提高了频繁增加字符串的效率。

package cn.tedu.test;

public class Test_Time {
	public static void main(String[] args) {
		String string = "";//定义一个空字符串
		
		long startTime = System.currentTimeMillis();//定义对字符串操作的开始时间
		for (int i = 0; i < 10000; i++) {
			string = string + i;
		}
		long endTime = System.currentTimeMillis();//定义对字符串操作后的时间
		long time = endTime - startTime;
		System.out.println("String消耗的时间为：" + time);//将执行的时间输出
		
		StringBuilder stringBuilder = new StringBuilder("");//创建字符串生成器
		startTime = System.currentTimeMillis();
		for (int j = 0; j < 10000; j++) {
			stringBuilder.append(j);
		}
		endTime = System.currentTimeMillis();
		time = endTime - startTime;
		System.out.println("StringBuilder消耗时间为：" + time);
		
	}
}

控制台显示：

String消耗的时间为：242
StringBuilder消耗时间为：1

• 通过对比可以看出，如果频繁的附加字符串，建议使用StringBuilder。新创建的StringBuilder对象初始容量为16个字符，可以自行指定初始长度
• 如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符
• 如果要使用StringBuilder最后输出字符串结果，可以使用toString()方法。
• 使用StringBuilder类中的方法可以动态的执行添加、删除和插入等字符串的编辑操作。

1. append()方法
   向字符串中追加内容，可实现接受任何类型的数据

语法格式：

append(content)

content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象

2. insert(int offset,arg)方法
   向字符串生成器中的指定位置插入数据内容。

语法格式：

insert(int offset arg)

offset：字符串生成器的位置，该参数必须大于0，且小于等于此序列长度
arg：将插入至字符串生成器位置。该参数可以是任何的数据类型或其他对象

package cn.tedu.test;

public class Test_Append {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder bf = new StringBuilder("hello");
		bf.insert(5, "world");
		System.out.println(bf.toString());
	}

}

控制台显示：

helloworld

3. delete(int start,int end)方法
   移出此序列的子字符串中的内容。从start开始，到end-1处的字符结束，如果结束字符不存在，那么一直到字符串尾部。
   若start=end则不发生改变

语法格式：

delete(int start,int end)

package cn.tedu.test;

public class Test_Append {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder bf = new StringBuilder("helloworld");
		bf.delete(5, 10);
		System.out.println(bf.toString());
	}

}

控制台显示：

hello

更多的StringBuilder类方法，可查询java.lang.StringBuilder的API说明