（21）String类的使用

- 日理万妓 2023-05-29 09:27 22阅读 0赞

一， String类的概述  
   1，字符串的连接  
   2，获取字符串信息  
   3，字符串操作  
   4，格式化字符串  
   5，字符串生成器

#### String类 ####

*  **什么是String**：由于char类型只能表示单个字符，所以要表示多个字符连接成的一个字符串必须通过java.lang中的String类来处理。
 *  声明一个字符串：在Java语言中字符串必须包含在双引号（""）之内。例如：“10.3”,“ADWQ21”,“你好”。这些都是字符串常量，字符串常量是系统能够显示任何文字信息，甚至是单个字符。不过要注意的是：在Java中用（""）包围的都是字符串，不能作为其他数据使用，比如"1+2"直接输出就是1+2，不会是3。也就是说双引号中是什么样子，使用的时候就是什么样子。
 *  string 声明为final，不可以继承，实现了Serializable接口，表示字符串支持序列化的，实现了Comparable接口，表示String可以比较大小
 *  创建字符串
    
     *  String(char\[\] value)：用一个字符数组创建String对象。
        
            char[] a = {'h','e','l','l','o'};
              String s = new String(a);
              //相当于
              String s = new String("hello");
     *  String(char\[\] value, int offset, int length)：提取字符数组中的一部分创建字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。截取位置下标从0开始。
        
            char[] a = {'h','e','l','l','o'};
              String s = new String(a,2,2);
              //相当于
              String s = new String("ll");
     *  除了通过以上几种使用String的构造方法来创建字符串变量外，还可通过字符串常量的引用赋值给一个字符串变量。
        
            String str1,str2;
              str1 = "我是一个学生";
              str2 = "我是一个学生";
        
        注意：这两个不同的引用指向同一个对象。

--------------------

#### 连接字符串 ####

对于已声明的字符串，可以对其进行相应的操作。连接字符串就是字符串操作中较简单的一种。
    可以多个字符串进行连接。也可以与其他数据类型进行连接。

*  连接多个字符串：使用“+”运算符可实现连接多个字符串功能。可以连接多个“+”运算符连接并产生一个String对象。
    
        public static void main(String[] args) {
         	String s1 = new String("hello");
         	String s2 = new String("world!");
         	String s3 = new String("i'm Java!");
         	String s = s1+" "+s2+" "+s3;
         	System.out.println("新的字符串："+s);
         }
         //执行结果
         新的字符串：hello world! i'm Java!
        
         Java中一句相连的字符串不能分开在两行写，而是必须用“+”连接成两个字符串。
 *  连接其他数据类型：字符串也可同其他基本数据类型进行连接。如果字符串同这些数据类型数据进行连接，会将这些数据直接转换成字符串。
    
     *  举例：
        
            int booktime = 4;
              float practice = 2.5f;
              System.out.println("我每天花费："+booktime+"小时看书，"+practice+"小时上机练习。");
              System.out.println("我每天花费："+booktime+"小时看书，"
              	+practice+"小时上机练习。总共花了："+(booktime+practice)+"小时。");
              System.out.println("我每天花费："+booktime+"小时看书，"
              	+practice+"小时上机练习。总共花了："+booktime+practice+"小时。");
              //执行结果
              我每天花费：4小时看书，2.5小时上机练习。
              我每天花费：4小时看书，2.5小时上机练习。总共花了：6.5小时。
              我每天花费：4小时看书，2.5小时上机练习。总共花了：42.5小时。
     *  结论：

1.  当其他类型与字符串连接时会自动调用toString方法，将其转换成字符串形式，然后参与连接。
2.  只要是“+”运算符左右其中一个操作数是字符串，编译器就会把另一个操作数转换成字符串形式。
3.  如果想要两个数字相加的结果应该使用括号将它们括起来。因为运算符中圆括号的优先级最高，所以会先执行圆括号中的内容再与其他字符串相连接。

--------------------

#### 获取字符串信息 ####

字符串作为对象，可以通过相应方法获取字符串的有效信息，如获取某字符串的长度、某个索引位置的字符串。

*  获取字符串的长度：length()方法可获取声明字符串对象的长度。
 *  字符串查找：String提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。
    
     *  indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引。此方法会从字符串的开始位置开始搜索str的位置，如果没有检索到字符串str，该方法返回-1。
        
            String str = "hello";
              System.out.println(str.indexOf('l'));
              //执行结果
              字符串l的索引是：2
     *  lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引。此方法会从当前字符串的开始位置检索字符串，并将最后一次出现str的索引位置返回。可以理解为从字符串的末尾开始检索，然后将第一次出现str字符串的索引位置（注意：索引仍旧要从左往右数）返回。如果没有检索到字符串str，则返回-1。
     *  indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
     *  lastIndexOf(int ch, int fromIndex)：返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。

--------------------

#### 字符串操作 ####

*  获取子字符串
    
     *  substring(int beginIndex)：返回一个新的字符串，它是此字符串的一个子字符串。该方法是从指定的索引开始截取到该字符串结尾的字串。
     *  substring(int beginIndex, int endIndex)：返回一个新字符串，它是此字符串的一个子字符串。该方法是从指定开始索引和指定结束索引来截取字符串。
        
            String str = "hello world!";
              String newStr1 = str.substring(6);
              String newStr2 = str.substring(1, 4);
              System.out.println("从指定索引截取到该字符串结尾："+newStr1);
              System.out.println("从指定开始索引和指定的结束索引截取该字符串："+newStr2);
              //执行结果
              从指定索引截取到该字符串结尾：world!
              从指定开始索引和指定的结束索引截取该字符串：ell
 *  去除字符串首尾空格：trim()方法，返回字符串的副本，忽略前导空白和尾部空白。
 *  字符串替换：replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。如果要替换的字符没有出现在字符串中，则返回原字符串。replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
    
        String str = "hello world!";
          String newStr = str.replace("l", "A");
          System.out.println("替换前的字符串："+str);
          System.out.println("替换后的字符串："+newStr);
          //执行结果
          替换前的字符串：hello world!
          替换后的字符串：heAAo worAd!
 *  判断字符串的开始与结尾
    
     *  startsWith(String prefix)：测试此字符串是否以指定的前缀开始。
     *  endsWith(String suffix)：测试此字符串是否以指定的后缀结束。
        
            String str = "hello world!";
              System.out.println("字符串str是以he开始吗："+str.startsWith("he"));
              System.out.println("字符串str是以ld结尾吗："+str.endsWith("ld"));
              //执行结果
              字符串str是以h开始吗：true
              字符串str是以d结尾吗：false
 *  判断字符串是否相等
    
     *  equals(Object anObject)：判断两个对象的内容是否相等
     *  equalsIgnoreCase(String anotherString)：将此 String 与另一个 String 内容进行比较，不考虑大小写。
 *  字母大小写转换
    
     *  toLowerCase(): 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
     *  toUpperCase()：使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 *  字符串分割
    
     *  split(String regex)：根据给定正则表达式的匹配拆分此字符串。即按照指定的规则分割字符串。
     *  split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串。limit：limit 参数控制模式应用的次数，因此影响所得数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正，那么模式将被应用尽可能多的次数，而且数组可以是任何长度。如果 n 为 0，那么模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。
     *  举例：
        
         *  例：
            
                String str = "192.168.0.1";
                  //按照.进行分割，使用转义字符“\\.”
                  String[] strArr1 = str.split("\\.");
                  //按照.进行(2-1)次分割，使用转义字符“\\.”
                  String[] strArr2 = str.split("\\.", 2);
                  //输出原字符串的值
                  System.out.println("原字符串的值为："+str);
                  System.out.print("全部分割的结果：");
                  for (int i = 0; i < strArr1.length; i++) {
                  	System.out.print(strArr1[i]+" ");
                  }
                  System.out.println();
                  System.out.print("分割（2-1）次的结果：");
                  for (int i = 0; i < strArr2.length; i++) {
                  	System.out.print(strArr2[i]+" ");
                  }
                  //执行结果
                  原字符串的值为：192.168.0.1
                  全部分割的结果：192 168 0 1 
                  分割（2-1）次的结果：192 168.0.1
 *  将字符串转化字节(getBytes())或字符(toCharArray())数组
    
        //将字符串转化成char型数组
         char[] chs = str3.toCharArray();//char[] chs = {'W','e',' '.....};
         for (int i = 0; i < chs.length; i++) {
         	System.out.println(chs[i]);
         }
         //将字符串转化成byte型数组
         byte[] bys = str3.getBytes();
         for (int i = 0; i < bys.length; i++) {
         	System.out.println(bys[i]);
         }

--------------------

#### 格式化字符串 ####

格式化字符串方法：format(String format, Object... args)，使用指定的格式字符串和参数返回一个格式化字符串。
    其中：
    format - 字符串的转换格式
    args - 格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，
    则忽略这些额外的参数。参数的数目是可变的，可以为 0。

*  日期和时间字符串格式化
    
     *  日期格式化
        
         *  常用的日期格式化转换符

<table> 
 <thead> 
  <tr> 
   <th align="left">转换符</th> 
   <th align="center">说明</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">%te</td> 
   <td align="center">一个月中的某一天（1~31）</td> 
   <td align="center">5</td> 
  </tr> 
  <tr> 
   <td align="left">%tb</td> 
   <td align="center">指定语言环境的月份简称</td> 
   <td align="center">Nov（英）、十一月（中）</td> 
  </tr> 
  <tr> 
   <td align="left">%tB</td> 
   <td align="center">月份全称</td> 
   <td align="center">November（英）、十一月（中）</td> 
  </tr> 
  <tr> 
   <td align="left">%tA</td> 
   <td align="center">星期几的全称</td> 
   <td align="center">Tuesday（英）、星期二（中）</td> 
  </tr> 
  <tr> 
   <td align="left">%ta</td> 
   <td align="center">星期几的简称</td> 
   <td align="center">Tue（英）、星期二（中）</td> 
  </tr> 
  <tr> 
   <td align="left">%tc</td> 
   <td align="center">包括全部日期和时间信息</td> 
   <td align="center">星期二 十一月 25 13：37：22 CST 2019</td> 
  </tr> 
  <tr> 
   <td align="left">%tY</td> 
   <td align="center">4位年份</td> 
   <td align="center">2019</td> 
  </tr> 
  <tr> 
   <td align="left">%tj</td> 
   <td align="center">一年中的第几天</td> 
   <td align="center">309</td> 
  </tr> 
  <tr> 
   <td align="left">%tm</td> 
   <td align="center">月份</td> 
   <td align="center">11</td> 
  </tr> 
  <tr> 
   <td align="left">%td</td> 
   <td align="center">一个月中的第几天</td> 
   <td align="center">05</td> 
  </tr> 
  <tr> 
   <td align="left">%ty</td> 
   <td align="center">2位年份</td> 
   <td align="center">19</td> 
  </tr> 
 </tbody> 
</table>

*  举例：
    
        @Test
          		public void test() {
          			Date date = new Date();
          			System.out.println("格式化之前的时间显示："+date);
          			System.out.println("今年是："+String.format("%tY", date)+"年");
          		}
          		//执行结果
          		格式化之前的时间显示：Tue Nov 05 17:38:40 CST 2019
          		今年是：2019年
 *  时间格式化
    
     *  常用的时间格式化转换符

<table> 
 <thead> 
  <tr> 
   <th align="left">转换符</th> 
   <th align="center">说明</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">%tH</td> 
   <td align="center">2位数字的24小时制的小时（00~23）</td> 
   <td align="center">14</td> 
  </tr> 
  <tr> 
   <td align="left">%tI</td> 
   <td align="center">12小时制小时（01~12）</td> 
   <td align="center">05</td> 
  </tr> 
  <tr> 
   <td align="left">%tk</td> 
   <td align="center">24小时制小时（0~23）</td> 
   <td align="center">5</td> 
  </tr> 
  <tr> 
   <td align="left">%tl</td> 
   <td align="center">12小时制小时（1~12）</td> 
   <td align="center">10</td> 
  </tr> 
  <tr> 
   <td align="left">%tM</td> 
   <td align="center">分钟（00~59）</td> 
   <td align="center">05</td> 
  </tr> 
  <tr> 
   <td align="left">%tS</td> 
   <td align="center">秒数（00~60）</td> 
   <td align="center">12</td> 
  </tr> 
  <tr> 
   <td align="left">%tL</td> 
   <td align="center">3为数字的毫秒数（000~999）</td> 
   <td align="center">920</td> 
  </tr> 
  <tr> 
   <td align="left">%tN</td> 
   <td align="center">9位数字的微秒数（9个0~9个9）</td> 
   <td align="center">062000000</td> 
  </tr> 
  <tr> 
   <td align="left">%tp</td> 
   <td align="center">指定语言环境上午或下午的标记</td> 
   <td align="center">下午（中文）、pm（英文）</td> 
  </tr> 
  <tr> 
   <td align="left">%tz</td> 
   <td align="center">相对于GMT RFC 82格式的数字时区偏移量</td> 
   <td align="center">+0800</td> 
  </tr> 
  <tr> 
   <td align="left">%tZ</td> 
   <td align="center">时区缩写形式的字符串</td> 
   <td align="center">CST</td> 
  </tr> 
  <tr> 
   <td align="left">%ts</td> 
   <td align="center">1970-01-01 00：00：00至现在经过的秒数</td> 
   <td align="center">1572947699</td> 
  </tr> 
  <tr> 
   <td align="left">%tQ</td> 
   <td align="center">1970-01-01 00：00：00至现在经过的毫秒数</td> 
   <td align="center">1572947657738</td> 
  </tr> 
 </tbody> 
</table>

*  举例：
    
        @Test
          		public void test() {
          			Date date = new Date();
          			System.out.println("1970-01-01 00：00：00至现在经过的秒数："+String.format("%ts", date));
        
          		}
          		//执行结果
          		1970-01-01 00：00：00至现在经过的毫秒数：1572947657738
          		//CST可以为如下4个不同的时区的缩写：
          		美国中部时间：Central Standard Time (USA) UT-6:00
          		澳大利亚中部时间：Central Standard Time (Australia) UT+9:30
          		中国标准时间：China Standard Time UT+8:00
          		古巴标准时间：Cuba Standard Time UT-4:00
          		//0时区：以英国伦敦格林尼治天文台为零时区
 *  常见的日期时间组合
    
     *  常见的日期和时间组合的格式

*  常规类型格式化
    
     *  常规转换符

<table> 
 <thead> 
  <tr> 
   <th align="left">转换符</th> 
   <th align="center">说明</th> 
   <th align="center">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">%c、%C</td> 
   <td align="center">格式化为字符类型</td> 
   <td align="center">‘a’</td> 
  </tr> 
  <tr> 
   <td align="left">%d</td> 
   <td align="center">格式化为十进制数</td> 
   <td align="center">10</td> 
  </tr> 
  <tr> 
   <td align="left">%o</td> 
   <td align="center">格式化为八进制数）</td> 
   <td align="center">11</td> 
  </tr> 
  <tr> 
   <td align="left">%x、%X</td> 
   <td align="center">格式化为十六进制数</td> 
   <td align="center">4b1</td> 
  </tr> 
 </tbody> 
</table>

--------------------

#### 字符串生成器 ####

*  **StringBuilder的作用**：当我们使用String对象的+号拼接字符串时，会在内存中穿件新的字符串对象。如果重复地对字符串进行修改，将极大的增加系统开销。所以增加了StringBuilder可变的字符序列，大大提高了频繁增加字符串的效率。
    
        public static void main(String[] args) {
          	//1.使用String拼接字符串
          	String str = "";
          	//获取当前的毫秒数
          	long startTime = System.currentTimeMillis();
          	for (int i = 0; i < 10000; i++) {
          		str += i;
          	}
          	//获取运行拼接字符串操作之后的当前时间
          	long endTime = System.currentTimeMillis();
          	long time = endTime - startTime;
          	System.out.println("String拼接字符串所消耗的时间="+time);
          	//2.使用StringBuilder拼接字符串
          	StringBuilder sbu = new StringBuilder("");
          	startTime = System.currentTimeMillis();
          	for (int i = 0; i < 10000; i++) {
          		sbu.append(i);
          	}
          	endTime = System.currentTimeMillis();
          	time = endTime - startTime;
          	System.out.println("StringBuilder拼接字符串所消耗的时间="+time);
          }
          //执行结果
          String拼接字符串所消耗的时间=197
          StringBuilder拼接字符串所消耗的时间=0
    
    \*\*结论：\*\*String拼接字符串的时间明显要多余StringBuilder的时间，所以String相当于创建了10000个新的对象，StringBuilder只会创建一个对象。
 *  **StringBuilder中的方法**：新创建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder最后输出字符串结果，可以使用toString()方法。

1.  append(content)：该方法用于向字符串生成器中追加内容，通过该方法的多个重载形式，可以接收任何类型的数据。其中：content：可以是任何形式的数据或者其他对象。
2.  insert(int offset, arg)：该方法用于想字符串生成器中的指定位置插入数据内容。其中：offset：字符串生成器的位置。0~此序列的长度。arg：可以是任何形式的数据或者其他对象。
    
        StringBuilder sbu = new StringBuilder("hello");
         	sbu.insert(1, "world");
         	System.out.println(sbu.toString());
         	//执行结果
         	hworldello
3.  delete(int start, int end)：移除此序列的子字符串中的字符。其中：start：将要删除字符串的起点位置。end：将要删除字符串的终点位置。如果start与end相等，则不发生更改。
    
        StringBuilder sbu = new StringBuilder("hello");
         	sbu.delete(0, 2);
         	System.out.println(sbu.toString());
         	//执行结果
         	llo
4.  sbu.setLength(int len);//设置当前StringBuilder对象的长度。
    
        sbu.setLength(0);//设置当前StringBuilder对象的长度
5.  reverse()：将此字符序列用其反转形式取代。

*  **StringBuffer和StringBuilder的区别**：  
    StringBuffer类与StringBuilder类的作用是一样的，区别是StringBuffer类是线程安全的，StringBuilder类是线程不安全的。

**StringBuilder方法append的例题：**

String str = null;
    	StringBuilder sb = new StringBuilder();
    	sb.append(str);
    	System.out.println(sb.length());//4
    	System.out.println(sb);//null
    	StringBuilder sb1 = new StringBuilder(str);//NullPointerException

StringBuilder方法append源码解析，当加入的字符串为null时，默认以“null”加入

private AbstractStringBuilder appendNull() { 
        int c = count;
        ensureCapacityInternal(c + 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

[下一章，（22）比较全面的正则表达式的使用][22]

[22]: https://blog.csdn.net/qq_41530004/article/details/103083650