【JAVA字符串最详细讲解】

怼烎@ 2023-01-08 02:06 427阅读 0赞

### JAVA字符串 ###

*  一、String类
 *   *  1、声明字符串
     *  2、创建字符串
 *  二、连接字符串
 *   *  1、连接多个字符串
     *  2、连接其他数据类型
 *  三、获取字符串信息
 *   *  1、获取字符串长度
     *  2、字符串查找
     *  3、获取指定索引位置的字符
 *  四、字符串操作
 *   *  1、获取子字符串
     *  2、去除空格
     *  3、字符串替换
     *  4、判断字符串的开始与结尾
     *  5、判断字符串是否相等
     *  6、按字典顺序比较两个字符串
     *  7、字母大小写转换
     *  8、字符串分割
 *  五、格式化字符串
 *   *  1、日期和时间字符串格式化
     *  2、常规类型格式化
 *  六、使用正则表达式
 *  七、字符串生成器
 *   *  1、StringBuilder类
     *  2、StringBuilder类的常用方法

# 一、String类 #

## 1、声明字符串 ##

**在JAVA语言中，字符串必须包含在一对双引号之间（“ ”）。例如：“23.23”、“ABCDE”、“你好”等都是字符串。  
可以通过以下语法格式来声明字符串变量：**

String str;
    //String : 指定该变量为字符串类型
    //str : 任意有效的标识符，表示字符串变量的名称

> 注意：声明字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”

## 2、创建字符串 ##

**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[],int offset,int length) 
    //提取字符数组a中一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，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");
    
    (4)通过字符串常量的引用赋值给一个字符串变量，例如：
    String str1,str2;
    str1 = "we are students";
    str2 = "we are students";
    //此时str1和str2引用相同的字符串常量，因此具有相同的实体。

# 二、连接字符串 #

## 1、连接多个字符串 ##

**使用“+"运算符可完成对多个字符串连接的功能。“ +"运算符可以连接多个运算  
符并产生一个String对象。**

**例1：创建类Join,在主方法中创建String型变量，并将字符变量连接的结果输出。**

public class Join                               //创建类
    {
        
        public static void main(String[] args)      //创建主方法
        {
        
            String s1 = new String("hello");        //声明String对象s1
            String s2 = new String("world");        //声明String对象s2
            String s = s1 + " " + s2;               //将对象s1和s2连接后的结果赋值给s
            System.out.println(s);                  //将s输出
        }
    }

> 注意：Java中一句相连的字符串不能分开在两行中写，如果一个字符串太长，必须将这两个字符串分在两行上书写，则需要使用“+”将两个字符串连起来，之后在加号处换行。

## 2、连接其他数据类型 ##

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

**例2：创建类Link，在主方法中创建数值型变量，实现将字符串与整型、浮点型变量相连的结果输出。**

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 + "小时上机练习");
        }
    }

![在这里插入图片描述][202101181806249.png]

> 注意：只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式，所以应该谨慎地将其他数据类型与字符串相连，以免出现意想不到的结果。

# 三、获取字符串信息 #

## 1、获取字符串长度 ##

**使用String类的length()方法获取声明的字符串对象的长度，语法如下：**

str.length();//str为字符串对象
    /*如下：*/
    String str = "we are students";
    int size = str.length();
    //上面字符串长度赋值给size,其值为15
    //表示length()方法获取的字符串长度包括字符串中的空格

## 2、字符串查找 ##

**String类提供了两种查找字符串的方法，即indexOf() 与lastIndexOf()方法。这两  
种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是  
搜索的字符或字符串首次出现的位置，lastIndexOf()方 法返回的是搜索的字符或  
字符串最后一次出现的位置。**

**(1) indexOf(String s)  
该方法用于返回参数字符串s在指定字符串中首次出现的索引位置，当调用字符串的indexOf()方法时，会从当前字符串的开始位置搜索s的位置，如果没有找到，该方法返回值是-1**

//语法如下：
    str.indexOf(substr);
    //str为任意字符串对象
    //substr为要搜索的字符串
    
    String s = "we are students";
    int size = s.indexOf("a");  //变量size的值为3
    //注意字符串下标是0~length()-1

**(2) lastIndexOf(String str)  
该方法用于返回指定字符串最后一次出现的索引位置，当调用字符串的lastIndexOf()时，会从字符串的结尾处，从右向左反向查找指定的字符串，如果找到指定的字符串，则返回该字符串中第一个字符的索引，如果没有查找到，则方法返回-1**

str.lastIndexOf(substr)
    //str:任意字符串对象
    //substr:要搜索的字符串

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

## 3、获取指定索引位置的字符 ##

**使用charAt（）方法可将指定索引处的字符返回。语法如下：**

str.charAt(int index)
    //str:任意字符串
    //index:整型值，用于指定要返回字符的下标

# 四、字符串操作 #

## 1、获取子字符串 ##

**通过String类的substring()方法可以对字符串进行截取，这些方法的共同特点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。  
substring()方法被两种不同的方法重载，来满足不同的需求：**

**（1）substring(int beginIndex):该方法返回的是从指定的索引位置开始截取直到该字符串结尾的字串。语法如下：**

str.substring(int beginIndex)
    //beginIndex指定从某一索引处开始截取字符串
    
    //例如：
    String str = "Hello World";//定义字符串str
    String substr = str.substring(3);//此时substr的值为：lo World

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

**（2）substring(int beginIndex,int endIndex):该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的字串。语法如下：**

substring(int beginIndex,int endIndex)
    //beginIndex:开始截取字符串的索引位置
    //endIndex:子字符串在整个字符串中的结束位置
    
    //例如：
    String str = "Hello World";//定义字符串str
    String substr = str.substring(0,3);//此时substr的值为:hel

## 2、去除空格 ##

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

str.trim()
    //str为任意字符串对象

**例3：在项目中创建类Blak,在主方法中创建String对象，将字符串变量原来的长度与去掉前导空格和尾部空格后的长度输出。**

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

![在这里插入图片描述][2021012112060219.png]

## 3、字符串替换 ##

**replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，语法如下：**

str.replace(char oleChar,char newChar)
    //oldChar:要替换的字符或字符串
    //newChar:用于替换原来字符串的内容

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

**例4：创建类NewStr，在主方法中创建String变量，将字符串变量中的字母a替换成A后的结果输出。**

public class NewStr {
         // 创建类
        public static void main(String args[]) {
         // 主方法
            String str = "address"; // 定义字符串str
            // 字符串str中的字符"a"替换成"A"后返回的新字符串newstr
            String newstr = str.replace("a", "A");
            System.out.println(newstr); // 将字符串newstr输出
        }
    }

![在这里插入图片描述][20210121121632577.png]

> 注意：如果要替换的字符oldChar在字符串中重复出现多次，replace（）方法会将所有oldChar全部替换成newChar,例如：  
> String str = “java project”;  
> String newstr = str.replace(“j”,“J”);//newstr的值为：Java proJect  
> 需要注意的是，要替换的字符oldChar的大小写要与原来字符串中字符的大小写保持一致，否则不能成功替换。

## 4、判断字符串的开始与结尾 ##

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

（1）startsWith()//该方法用于判断当前字符串对象的前缀是否为参数指定的字符串
    str.startsWith(String prefix)
    //prefix是指作为前缀的字符
    
    （2）endsWith()//该方法用于判断当前字符串是否以给定的子字符串结束
    str.endsWith(String suffix)
    //suffix是指作为后缀的字符串

**例5：创建类StartOrEnd，在主方法中创建String变量，并判断变量的前导和后置字符串。**

public class StartOrEnd {
         // 创建类
    	public static void main(String args[]) {
         // 主方法
    		String num1 = "22045612"; // 定义字符串num1
    		String num2 = "21304578"; // 定义字符串num2
    		boolean b = num1.startsWith("22"); // 判断字符串num1是否以'22'开头
    		boolean b2 = num1.endsWith("78"); // 判断字符串num1是否以'78'结束
    		boolean b3 = num2.startsWith("22"); // 判断字符串num2是否以'22'开头
    		boolean b4 = num2.endsWith("78"); // 判断字符串num2是否以'78'结束
    		System.out.println("字符串num1是以'22'开始的吗？" + b);
    		System.out.println("字符串num1是以'78'结束的吗？" + b2); // 输出信息
    		System.out.println("字符串num2是以'22'开始的吗？" + b3);
    		System.out.println("字符串num2是以'78'结束的吗？" + b4);
    	}
    }

![在这里插入图片描述][20210121124127642.png]

## 5、判断字符串是否相等 ##

**要比较两个字符串内容是否相等，应该使用equals()方法和equalsIgnoreCase()方法。**

（1）equals()方法
    //如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true,语法如下：
    str.equals(String otherstr)
    //str  otherstr 是要比较的两个字符串对象
    
    （2）equalsIgnoreCases()方法
    //使用equals（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase（）方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型，语法如下：
    str.equalsIgnoreCase(String otherstr)
    //str  otherstr是要比较的两个字符串对象

**通过下面的例子可以看出两种比较方法的区别。**

**例6：创建类Opinion，在主方法中创建String型变量，实现判断两个字符串是否相等，并输出结果。**

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

![在这里插入图片描述][20210121143531701.png]

## 6、按字典顺序比较两个字符串 ##

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

str.compareTo(String otherstr)
    //str  otherstr是要比较的两个字符串对象

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

**例7：创建Wordbook类，在主方法中创建String变量，使用compareTo（）方法将字符变量进行比较，并将比较结果输出。**

public class Wordbook {
         // 创建类
    	public static void main(String args[]) {
         // 主方法
    		String str = new String("b");
    		String str2 = new String("a"); // 用于比较的3个字符串
    		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比较的结果输出
    	}
    }

![在这里插入图片描述][20210121144947425.png]

## 7、字母大小写转换 ##

**字符串的toLowerCase()方法可将字符串中的所有字符从大写字母改写为小写字▲  
母，而toUpperCase()方法可将字符串中的小写字母改写为大写字母。**

**（1）toLowerCase()方法：该方法将String转换为小写。如果字符串中没有该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，字符长度与原来字符长度相等。语法如下：**

str.toLowerCase()
    //str 为要进行转换的字符串

**（2）toUpperCase()方法：该方法将String转换为大写。如果字符串中没有该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，字符长度与原来字符长度相等。语法如下：**

str.toUpperCase()
    //str 为要进行转换的字符串

> 注意：使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字和非字符不受影响。

## 8、字符串分割 ##

**split()方法根据指定的分割符对字符串进行分割，并将分割后的结果存放在字符串数组中。split()方法提供两种重载形式。**

（1）split(String sign)
    //该方法可根据给定的分割符对字符串进行拆分，语法如下：
    str.split(String sign)
    //sign为分割字符串的分割符，也可以使用正则表达式
    
    （2）split(String sign,int limit)
    //该方法可根据给定的分割符对字符串进行拆分，并限定拆分次数，语法如下：
    str.split(String sign,iny limit)
    //sign 为分割字符串的分隔符，也可以使用正则表达式
    //limit 为模式匹配次数，如果值设置为n，那么将根据正则表达式匹配(n-1)次，得到的结果数组的长度不会大于n,数组的最后一项是最后匹配的分割符以后的全部内容

> 注意：没有统一的对字符进行分割的符号，如果想定义多个分割符，可使用符号“|”，例如，”，| =“表示分割符分别为”，“、”=“。

**例8：创建Division类，在主方法中创建String型变量，并将字符变量进行分割，将分割后的结果输出。**

public class Division{
        
    	public static void main(String[] args) {
        
    		// 创建字符串
    		String str = "192.168.0.1";
    		// 按照"."进行分割
    		String[] firstArray = str.split("\\.");
    		// 按照"."进行两次分割
    		String[] secondArray = str.split("\\.", 2);
    		// 输出str原值
    		System.out.println("str的原值为：[" + str + "]");
    		// 输出全部分割的结果
    		System.out.print("全部分割的结果：");
    		for (String a : firstArray) {
        
    			System.out.print("[" + a + "]");
    		}
    		System.out.println();// 换行
    		// 输出分割两次的结果
    		System.out.print("分割两次的结果：");
    		for (String a : secondArray) {
        
    			System.out.print("[" + a + "]");
    		}
    		System.out.println();
    	}
    }

![在这里插入图片描述][20210121183038969.png]

# 五、格式化字符串 #

**format()方法的两种重载形式：**

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

str.format(String format,Object...args)
    //format:格式化字符串
    //args:格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0

**（2）format(Local l,String format,Object…args)  
//l:格式化过程中要应用的语言环境，如果l为null,则不进行本地化  
//format:格式化字符串  
//args:格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0**

## 1、日期和时间字符串格式化 ##

**在应用程序设计中，经常需要显示时间和日期。如果想输出满意的日期和时间格式，一般需要编写大量的代码经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。**

**1、日期过格式化：如下例子：**

//返回一个月的天数
    Date date = new Data();//创建Date对象date
    String s = String.format("%te",date);//通过format方法对date进行格式化
    //s是当前日期中的天数，如今天是15号，则s的值为15；%te是转换符

**常见的日期格式转换符如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70]  
**例9：创建类Eval，实现将当前日期信息以4位年份、月份全称、2位日期形式输出。**

import java.util.*;
    
    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 + "号");
    	}
    }

**2、时间格式化 使用format()方法对时间进行格式化时，会用到时间格式化转换符，时间格式化转换符要比日期转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒。常用的时间格式化转换符如下表所示。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 1]

## 2、常规类型格式化 ##

**在程序设计过程中，经常需要对常规类型的数据进行格式化，例如格式化为整数，格式化为科学计数表示等，在Java中可以使用常规类型的格式化转换符来实现，下表列出了常规类型的格式化转换符。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 2]  
**例10：创建类General，在主方法中实现不同数据类型到字符串的转换。**

public class General {
         // 新建类
    	public static void main(String[] args) {
         // 主方法
    		String str = String.format("%d", 400 / 2); // 将结果以十进制显示
    		String str2 = String.format("%b", 3 > 5); // 将结果以布尔形式显示
    		String str3 = String.format("%x", 200); // 将结果以十进制格式显示
    		System.out.println("400的一半是：" + str); // 输出格式化字符串
    		System.out.println("3>5正确吗：" + str2);
    		System.out.println("200的十六进制数是：" + str3);
    	}
    }

![在这里插入图片描述][20210123160244632.png]

# 六、使用正则表达式 #

**正则表达式通常被用于判断语句中，用来检查某一字符是否满足某一个格式。正则表达式是含有一些特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符，例如，“\\d”表示数字0~9中的任何一个，“\\d”就是元字符。正则表达式中元字符及其意义如下图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 3]

> 说明：在正则表达式中“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转义字符“\\”。

**在使用正则表达式时，如果需要某一类型的元字符多次输出，逐个输入就相当麻烦，这时可以使用正则表达式的限定元字符来重复次数。下表列出了常用限定符及其含义。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 4]

**在正则表达式中还可以用方括号把多个字符括起来，方括号中各种正则表达式代表不同的含义。下表列出了方括号中元字符及其含义。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 5]  
**例11：创建类Judge,在主方法中实现使用正则表达式来判断指定的变量是否为合法的E-mail地址。**

public class Judge {
        
    	public static void main(String[] args) {
        
    		 // 定义要匹配E_mail地址的正则表达式
    		String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";
    		String str1 = "aaa@"; // 定义要进行验证的字符串
    		String str2 = "aaaaa";
    		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地址格式");
    		}
    	}
    }

![在这里插入图片描述][20210123164828123.png]

# 七、字符串生成器 #

**引入实例：创建Jerque类，在主方法中编写如下代码，验证字符串操作和字符串生成器操作的效率。**

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("Sting消耗时间：" + 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、StringBuilder类 ##

**StringBuilder类，即字符串生成器，新创建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度，也可以动态地执行添加、删除和插入等字符串的编辑操作，大大提高了频繁增加字符串的效率。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。**

## 2、StringBuilder类的常用方法 ##

**StringBuilder类的构造方法有很多，主要是参数上的区别，这里我们主要介绍几种在编程中经常会用到的方法。  
（1）append()方法：该方法用于字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int boolean char String double或者另一个字符串生成器等。语法如下：**

append(content)
    //content表示要追加的内容，可以是任何类型的数据或者其他对象

**（2）insert(int offset ,arg)方法：该方法用于向字符串生成器中的指定位置插入数据内容，通过该方法的多个重载形式，可实现接受任何类型的数据，如int boolean char String double或者另一个字符串生成器等。语法如下：**

insert(int offset arg)
    //offset:字符串生成器的位置，该参数必须大于等于0，且小于等于此序列的长度
    //arg:将插入至字符串生成器的位置。该参数可以是任何类型的数据或者其他对象
    
    例如：向字符串生成器中指定位置添加字符
    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)
    //start:将要删除的字符串的起点位置
    //end:将要删除字符串的终点位置
    
    例如，删除指定位置的子字符串
    StringBuilder bf = new StringBuilder("StringBuilder");//创建字符生成器
    bf.delete(5,10);//删除的子字符串
    System.out.println(bf.toString());//此时输出信息为Strinder

[202101181806249.png]: /images/20221119/51ce1ec0786d479698c42ae06957c14f.png
[2021012112060219.png]: /images/20221119/554c1daa10d74fba920da932b8cfbf8a.png
[20210121121632577.png]: /images/20221119/cc38d66529af4b8485c271c0d72e65b6.png
[20210121124127642.png]: /images/20221119/45acc1cd7f474a839e6fdcafcc8a70f2.png
[20210121143531701.png]: /images/20221119/08a118669985403cb99f7e2b752352cc.png
[20210121144947425.png]: /images/20221119/408a0ed114fc4161b74553ba0d78e4fc.png
[20210121183038969.png]: /images/20221119/61deba97703e4cbca13b1c2d6aeef66f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70]: /images/20221119/3fa87208a97c4f5eb71c5101e38869f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 1]: /images/20221119/a684452231b34e11a0b2c4b0cca29553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 2]: /images/20221119/30e4d46b689e443bbc44937ee764c039.png
[20210123160244632.png]: /images/20221119/744e33ff488f47eb831354c43e70f83f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 3]: /images/20221119/8d6149acec32402a8a18c586f51e7c1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 4]: /images/20221119/64ddfa35e68e4cae801af5faa3f90915.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70 5]: /images/20221119/d0df9bd1022145e18aa05b566df739e8.png
[20210123164828123.png]: /images/20221119/4316e1174ee74a7091933c4fe9b86f72.png