JAVA第十章总结

三岁就很牛.

已于 2023-05-12 12:14:45 修改

阅读量84

点赞数

文章标签： java

于 2023-05-12 11:48:20 首次发布

本文链接：https://blog.csdn.net/JHsjdh/article/details/130638102

版权

10.1 String类

10.1.1 声明字符串

在Java语言中，字符串必须包含在一堆双引号（"")之内。

例如："23.23"、"ABCDE"、"你好"

可以通过以下语法格式莱声明字符串变量：

String str;

String:指定该变量为字符串类型。

str:任意有效的标识符，表示字符串变量的名称。

声明字符串变量s，代码如下：

String s;

例如：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  String s;
  System.out.print(s);
 }
 
}

运行结果如下：

翻译结果：

字符串初始化第一种方式

例题：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  String s;
  //字符串变量初始化
  s = "你好";
  System.out.print(s);
 }
 
}

运行结果如下：

第二种方法

例题：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  String s;
  //字符串变量初始化
  
  s = new String("你好");
  System.out.print(s);
 }
 
}

运行结果：

10.1.2创建字符串

在Java语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法。String类的常用构造方法如下：

1.String(char a[])

该方法用一个字符数组a创建String对象，代码如下：

例题：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  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);
 }
 
}

2.String(char a[],int offset,int length)

该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。代码如下：

例题：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  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,1,4);
  System.out.println(str);
 }
 
}

3.String(char[] value)

该构造犯法可分配一个新的String对象，使其表示字符组参数中所有元素连接的结果。代码如下：

例题：

package a;
 
public class Test1 {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//字符串变量的申明
		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);
		System.out.println(str);
		//字符串相连接
		System.out.println(s+st);
	}
 
}

除通过以上几种使用String类的构造方法赖创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串。代码如下：

例题：

package a;
 
public class Test1 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //字符串变量的申明
  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,1,4);
  System.out.println(str);
  //字符串相连接
  System.out.println(s+st);
 }
 
}

10.2连接字符串

10.2.1连接多个字符串

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。

例题10.1

package package1;
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"和对象链接并将结果赋值给s
  System.out.println(s);    //将s输出
 
 }
 
}

10.2.2连接其他数据类型

字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型进行连接，会将其他数据类型的数据直接转换成字符串。

例题10.2

package package1;
 
public class Link {
 public static void main(String[] args) {
  int booktime = 4;
  float practice = 2.5f;
  System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");
 
 }
 
}

运行结果

如果将例题10.2中输出语句修改为：

System.out.println("我每天花费"+booktime+"小时看书;"+(practice+booktime)+"小时上机练习");

修改后运行结果：

由于运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。

10.3获取字符串信息

10.3.1获取字符串长度

使用String类的length（）方法可获取声明的字符串对象的长度。语法如下：

str.length();

str为字符串对象

获取字符串长度，代码如下：

String str ="We are students";
int size = str.length();

上段代码是将字符串str的长度赋值给int型变量size，此时变量size的值为15，这表示length()方法返回的字符串的长度（包括字符串中的空格）

10.3.2字符串查找

String类提供了两种查找字符串的方法，是indexOf()与lastIndexOf方法。

1.indexOf(String s)

该方法用于但会参数字符串s在指定字符串中首次出现的索引位置

语法：str.indexOf(substr)

str:任意字符串对象

substr: 要搜索的字符串

查找字符a在字符串str中的索引位置，代码如下;

String str ="We are students";
int size = str.indexOf("a")       //变量size的值是3

2.lastIndexOf(String str)

该方法用于但会指定字符串最后一次出现的索引位置

语法：str.lastIndexOf(substr)

str:任意字符串对象

substr:要搜索的字符串

注意：如果lastIndexOf()方法中的参数是空字符串""(注意没有空格)，则返回的结果与调用length()方法的返回结果相同。

例题10.3

package a;
 
public class Text {      //创建类
 
	public static void main(String[] args) {          //主方法
		// TODO Auto-generated method stub
		String str ="We are students";               //定义字符串在str
		int size = str.lastIndexOf("");              //定义字符串在str中的索引位置赋值给变量size
		System.out.println("空字符串在字符串str中的索引位置是："+size);  //将变量size输出
		System.out.println("字符串str的长度是："+str.length());        //将字符串str的长度输出
	}
 
}

10.3.3获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。

语法：str.charAt(int index)

str:任意字符串。

index:整型值，用于指定要返回字符的下标。

例题10.4

 
public class Ref {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str ="hellowworld";//定义字符串为str
  char mychar=str.charAt(6);//将字符串中索引位置为6的字符返回
  System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息
 }
 
}

10.4字符串操作

10.4.1获取子字符串

通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。

1.substring(int beginlndex)

该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串，

语法：str.substring(int beginIndex)

其中，beginIndex指定从某一索引处开始截取字符串

截取字符串，代码如下：

String str ="Hello World";         //定义字符串str
String substr = str.substring(3);      //获取字符串，此时substr值为lo World

beginlndex：开始截取子字符串的索引位置

endIndex：子字符在整个字符串中的结束位置

例题10.5

 
public class Subs {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str ="《将进酒》：李白（唐）";
  String substr=str.substring(6,8);//对字符串进行截取
  System.out.println("《将进酒》的作者是："+substr);//输出截取后的字符串 
 
}

10.4.2去除空格

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

语法：str.trim()

str为任意字符串对象

例题10.6

 
public class Blak {             //创建类
 
	public static void main(String[] args) {          //主方法
		// TODO Auto-generated method stub
			String str ="  Java    class    ";        //定义字符串str
			System.out.println("字符串原来的长度："+str.length());      //将str原来的长度输出
			//将str去掉前导和尾部的空格后的长度输出
			System.out.println("去掉空格后的长度："+str.trim().length());
	}
 
}

10.4.3字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。

语法;str.replace(CharSequence target,CharSequence replacement)

target:要替换的字符或字符串

replacement：用于替换原来字符串的内容

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

例题10.7

 
public class NewStr {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str = "address";
  String newstr =str.replace("a","A");//把a替换
  System.out.println(newstr);//输出
  
  
  
  
 }
 
 
}

10.4.4判断字符串的开始与结尾

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

1.stsrtsWith()方法

该方法用于判断当前字符串对象的前缀是否为参数指定的字符串

语法：str.stsrtsWith(String prefix) //prefix是指作为后缀的字符串

2.endsWith()方法

该方法用于判断当前字符串是否为以给定的子字符串结束

语法:str.endWith(String suffix) //suffix是指作为后缀的字符串

例题10.8

 
public class StartOrEnd {        //创建类
 
 public static void main(String[] args) {    //主方法
  // TODO Auto-generated method stub
  String num1="22045612";            //定义字符串num1
  boolean b = num1.startsWith("22"); //判断真假
  System.out.println("字符串num1是以22开始的吗？"+b);
  String num2="21304578";        //定义字符串num2
  boolean b2 = num2.endsWith("78");     //判断
  System.out.println("字符串num2是以78结尾的吗"+b2);       //输出信息
  
  
  
 }
 
}

10.4.5判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”

代码：

String tom =new String("I am a student");
	String jerry = new String("I am a student");
	boolean b = (tom == jerry);

布尔类型变量b的值位false,因为字符串是对象，tom、jerry是引用，如下图：

1.equals()方法

如果两个两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。

语法：str.equals(String otherstr) //其中str、otherstr是要比较的两个字符串对象

2.equalslgnoreCase()方法

使用equals()方法对字符串进行比较时是区分大小写的，而使用equalslgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型

语法如下：equalslgnoreCase(String otherstr) //其中str、otherstr是要比较的两个字符串对象

例题10.9

 
public class Opinion {             //创建类
 
 public static void main(String[] args) {      //主方法
  // TODO Auto-generated method stub         
  String s1 =new  String("abc");              //创建字符串对象s1
  String s2 =new  String("ABC");                //创建字符串对象s2
  boolean b =s1.equals(s2);                    //使用equals()方法比较s1与s2
  boolean b2 =s1.equalsIgnoreCase(s2);          //使用equalsIgnoreCase()方法比较s1与s2
  System.out.println(s1+"equals"+s2+":"+b);       //输出信息
  System.out.println(s1+"equals"+s2+":"+b2);
 
 }
 
}

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

compareToO方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。

如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。

语法如下：str.compareTo(String otherstr) //str、otherstr是要比较的两个字符串对象

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

例题10.10

 
public class Wordbook {               //创建类
 
	public static void main(String[] args) {           //主方法
		// TODO Auto-generated method stub
		String str = new String ("b");              //用于比较的3个字符串
		String str2 = new String ("a");
		String str3 = new String ("c");
		System.out.println(str+"compareTo"+str2+":"+str.compareTo(str2));    //将str与str2比较的结果输出
		System.out.println(str+"compareTo"+str3+":"+str.compareTo(str3));   //将str与str3比较的结果输出
	}
 
}

10.4.7字母大小写转换

String 类的toLowerCase（)方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase（)方法可将字符串中的所有小写字母改写为大写字母。

1.toLowerCase（)方法

该方法将字符串中的所有大写字母转换为小写

语法：str.toLowerCase（) //str是要进行转换的字符串

2. toUpperCase（)方法

该方法将字符串中所有小写字母转换为大写

语法：str.toUpperCase（) //str是要进行转换的字符串

例题10.11

  
public class UpAndLower {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stubString stri = "Oh My God!";
   String lower = stri.toLowerCase();         //toLowerCase()将原字符串中的每个大写字母转化为小写，字符串长度不变
   System.out.println(lower);
   String upper = stri.toUpperCase();       //toUpperCase(）将原字符串中的每个小写字母转化为大写，字符串长度不变
   System.out.println(upper);
    }
}

10.4.8字符串分割

1.split(String sign)

该方法可根据给定的分割符对字符串进行拆分

语法：str.split(String sign) //sign为分割字符串的分割符，也可以使用正则表达式

2.split(String sign，int limit)

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数

语法：str.split(String sign，int limit)

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

limit:限制的分割次数

例题10.12

//10.4.8字符串的分割
		String strin="192.168.0.1";
		String[] split =strin.split("\\.");//转义，分割为4个部分
		for(String temp: split) {
			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:格式化字符串中由格式说明字符引用的参数

2.format(Local I,String format,Object...args)

该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定语言环境。

语法：str.format(Local I,String format,Object...args)

I:格式化过程中要应用的语言环境。

format:格式字符串

args：格式字符串中由格式说明符引用的参数。可以为0

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

1.日期格式化

例子：

Date data = new Date();      //创建Date对象date
String s = String.formate("%te",date);      //通过format()方法对date进行格式化

常用的日期格式化转换符如下表：

例题10.13

import java.util.Date;								//导入java.util.Date类
public class Eval {									//新建类
	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+"号");
	}
 
}

结果如下：

10.5.2时间格式化

使用 format()方法不仅可以完成日期的格式化也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等。

例题10.14

import java.util.Date;									//导入java.util.Date类
public class GetDate {									//新建类
	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+"秒");
		//输出的信息
	}
 
}

10.5.3格式化常见的日期时间组合

格式化日期与时间组合的转换符定义了各种日期时间组合式，其中常见的如图所示。

例题10.15

 
import java.util.Date;								//导入java.util.Date类
public class DateAndTime {							//新建类
	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.4常规类型格式化

常规类型格式化可应用于任何参数类型，可通过表中的转换符来实现。

例题10.16

package Package10;
 
public class General {//新建类
 
	public static void main(String[] args) {//主方法
		String str = String.format("%d", 400 / 2);//将结果以十进制格式显示//将结果以 boolean 型显示//将结果以十六进制格式显示
		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);
		
	}
 
}

每节总结代码

import java.util.Date;
 
public class Tast4 {
 
	public static void main(String[] args) {
		//格式化字符串
		//String 格式化后的字符串 = String.format(格式,字符串);
		
		//日期与时间格式化
		Date date = new Date();
		System.out.println(date);
		//日期格式化
		String year = String.format("%tY", date);
		String month = String.format("%tm", date);
		String day = String.format("%td", date);
		System.out.println(year + "年" + month + "月" + day +"日");
		//时间格式化
		String hour = String.format("%tH", date);
		String minute = String.format("%tM", date);
		String second = String.format("%tS", date);
		System.out.println(hour + "时" + minute + "分" + second + "秒");
		//常用日期时间组合格式化
		String dateFormat = String.format("%tF", date);
		String timeFormat = String.format("%tT", date);
		System.out.println(dateFormat + " " + timeFormat);
	}
 
}

结果如下：

10.6使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有-些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字0~9中的任何一个，“\d”就是元字符。正则表达式中的元字符及其意义如表中所示。

在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字特可代表方括号中的任何一个字符。例如，reg ="[abc]4”，这样字符串 a4、b4、c4 都是和正则表达式匹配的字符串，方括号元字符还可以为其他格式。如：

1.[456]: 表 4、5、6之外的任何字符。

2.[a-r]: 代表 a~r中的任何一个字母。

3.[a-zA-Z]: 可表示任意一个英文字母。

4.[a-e[g-z]]: 代表a~e或 g~z中的任何一个字母(并运算)。

5.[a-o&&[def]]: 代表字母 d、e、f (交运算)。

6.[a-d&&[bc]]: 代表字母a、d (差运算)。

在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如：“A*”代表A可在字符串中出现0次或多次。限定修饰符的用法如表所示。

例题10.17

public class Judge {
 
	public static void main(String[] args) {
		String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";//定义要匹配E-mail地址的正则表达式
		String str1 = "aaa@";//定义要进行验证的字符串
		String str2 = "aaaaaa";
		String str3 = "1111@111ffyu.dfg.com";
		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地址格式");
		}
		
		String er = "\\d{13}";
		String b = "1234567890123";
		if(b.matches(er)) {//判断字符串变量是否与正则表达式匹配
			System.out.println(b + "是一个合法的E-mail地址格式");
		}
	}
	
}

正则表达式分析:
通常情况下E-mail的格式为“X@X.com.cn”字符 X 表示任意的一个或多个字符，@为 E-mail 地址中的特有符号，符号@后还有一个或多个字符，之后是字符“.com”，也可能后面还有类似“.cn”的标记。总结 E-mail 地址的这些特点，可以书写正则表达式“\\w+@\\w+(\\.\\w{2,3})\\w{2,3}”来匹配E-mail地址。字符集“\\w”匹配任意字符,符号“+”表示字符可以出现 1次或多次，表达式“(\\.\\w{2,3})*”表示形如“com”格式的字符串可以出现0次或多次。而最后的表达式“\\.\\w{2,3}”用于匹配 E-mail 地址中的结尾字符，如“.cn”。

10.7字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类大大提高了频繁增加字符串的效率。

例题10.18

 
package Package10;
	public class Jerque{//新建类
		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 i= 0;i< 10000; i++){//利用 for 循环进行操作
		builder.append(i);//循环追加字符
		}
		endTime = System.currentTimeMillis();//更新操作后的时间//将操作时间输出
		time = endTime - starTime;//更新追加操作执行的时间
		System.out.println("StringBuilder 消耗时间:"+ time);//将操作时间输出
 
	}
 
}

通过这一实例可以看出，两种操作执行的时间差距很大。如果在程序中频繁地附加字符串，建议使用 StringBuilder类新创建的 StringBuilder对象初始容量是16个字符,可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder 对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder类最后输出字符串结果，可使用 toString()方法。利用 StringBuilder 类中的方法可动态地执行添加、删除和插入等字符串的编辑操作。该类的常用方法如下。

1.append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:

append(content)

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

2.insert(int offset, arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:

insert(int offset arg)

ofset:

字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。

arg:

将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。

向字符串生成器中指定的位置添加字符，代码如下:

StringBuilder bf = new StringBuilder("hello");//创建字符生成器
 
bf.insert(5，"world");//添加至字符生成器的位置及内容
 
System.out.println(bf.toString());//此时输出信息为hellword

3.delete(int start , int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的 stat 处开始，一直到索引 end-1 处的字符如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。语法如下:

delete(int start , int end)

1.start: 将要删除的字符串的起点位置。

2. end:将要删除的字符串的终点位置。

删除指定位置的子字符串，代码如下：

StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器
 
bf.delete(5,10);//删除的子字符串
 
System.out.println(bf.toString());//此时输出的信息为Strinder

三岁就很牛.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA第十章总结

在Java语言中，字符串必须包含在一堆双引号（"")之内。例如："23.23"、"ABCDE"、"你好"可以通过以下语法格式莱声明字符串变量：String str;String:指定该变量为字符串类型。str:任意有效的标识符，表示字符串变量的名称。声明字符串变量s，代码如下：String s;运行结果如下：第一种方式运行结果如下：第二种方法。
复制链接

扫一扫