黑马程序员---String类，StringBuffer类，StringBuilder类，基本数据类型对象包装类

2023-12-18 17:37:09

String类：

String类被final修饰，因此不可以创建String类的子类。

  1: class Demo 
  2: {
  3:   public static void main(String[] args) 
  4:   {
  5:     String s=new String();
  6:     String s1="";
  7:     //以上两种方法是等价的。
  8: 
  9:     //s2是一个类类型的变量，它指向的"abc"为一个对象
 10:     //字符串的最大特点是，一旦被初始化，就不可改变
 11:     String s2="abc";
 12: 
 13:     //此时改变的是s2的指向，不是字符串对象。
 14:     s2="kk";
 15:     String s3=new String("abc");
 16: 
 17:     //s2和s3是有区别的，s1在内存中只存在一个对象，而s2在内存中存在两个对象
 18: 
 19: 
 20:   }
 21: }
 22:

String类的常用方法：

1.获取：

<1>字符串的长度：length( )方法，返回值为int类型。

<2>根据位置获取位置上的字符：charAt(int index)，返回值为char类型。

<3>根据字符获取该字符在字符串上的位置：indexOf(int ch)，ch为字符，传递的是ASCII码值，返回值为字符在字符串中第一次出现的位置。

indexOf(int ch,int fromIndex)，从fromIndex指定的位置开始获取ch的位置。

indexOf(String str)，返回的是str在字符串中第一次出现的位置。

indexOf(String str,int fromIndex)，从fromIndex指定的位置开始获取str的位置，如果没有找到，则返回-1。

lastIndexOf(int ch)，反向索引，从右往左找，但是角标依旧是从左到右从0开始排序。

2.判断：

<1>字符串中是否包含某一个子串：contains(str)，返回值为boolean型。

<2>字符串中是否有内容：isEmpty( )，返回值为boolean型。

<3>字符串是否以指定内容开头：startsWith(str)，返回值为boolean型。

<4>字符串是否以指定内容结尾：endsWith(str)，返回值为boolean型。

<5>判断字符串中的内容是否相同：equals(str)

<6>判断字符串的内容是否相同，忽略大小写：equalsIgnoreCase( )

3.转换：

<1>将字符数组转换成字符串：

构造函数：String(char[])

String(char[],offset,count)将字符数组中的一部分转换成字符串，offset为起始位，count为个数

静态方法：copyValueOf(char[])

copyValueOf(char[],offset,count)

valueOf(char[])

valueOf(char[],offset,count)

<2>将字符串转成字符数组：toCharArray( )

<3>将字节数组转换成字符串：

构造函数：String(byte[])

String(byte[],offset,count)

<4>将字符串转换成字节数组：getBytes( )

<5>将基本数据类型转成字符串：valueOf( 基本数据类型 )

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4.替换：

replace(oldChar,newChar)，用新的字符子串替换旧的字符子串。

5.切割：

split(regex)，以regex进行切割。

  1: 
  2: //以逗号进行切割，得出的结果为zhangsan  lisi  wangwu
  3: String s="zhangsan,lisi,wangwu";
  4: String[] arr=s.split(",");
  5:

6.获取字符串中的一部分：

<1>subString(begin)，从指定位置一直截取到字符串结尾处。

<2>subString(begin,end)，从指定开始位置一直截止到指定的结束位置，包含头，不包含尾，获取整个字符串，从0到s.length。

7.转换，去除空格，比较：

<1>将字符串转换成大写或者小写：toUpperCase( )和toLowerCase( )

<2>将字符串两端的多个空格去除：trim( )

<3>对两个字符串进行自然顺序的比较：

compareTo(string)，如果此字符串等于参数字符串，则返回值为0，如果此字符串大于参数字符串，返回值为正数，如果此字符串小于参数字符串，则返回负数

练习：查找子字符串在字符串中出现的次数

  1: public static int getSubCount_1(String str,String s)
  2:   {
  3:     //设置一个计数器
  4:     int count=0;
  5:     int index=0;
  6: 
  7:     //获取到子串s的位置
  8:     while((index=str.indexOf(s))!=-1)
  9:     {
 10:       System.out.println("Str="+str);
 11:       //从s开始往后推s.length()个位置，然后截取子串。
 12:       str=str.subString(index+s.length());
 13:       count++;
 14:     }
 15:       return count;
 16: 
 17:   }
 18:   
 19:   public static int getSubCount_2(String str,String s)
 20:   {
 21:     int count=0;
 22:     int index=0;
 23:     while((index=str.indexOf(s,index))!=-1)
 24:     {
 25:       System.out.println("index="+index);
 26:       //将index进行叠加，每次都往后推s.length()个位置，然后在从新的位置进行搜索
 27:       index=index+s.length();
 28:       count++;
 29:     }
 30: 
 31:     return count;
 32: 
 33:   }

例：获取两个字符串中的最大相同子串。

  1: 
  2: public static String getMaxSubString(String s1,String s2)
  3: {
  4:   String max="",min="";
  5:   max=(s1.length()>s2.length())?s1:s2;
  6:   min=(max==s1)?s2:s1;
  7: 
  8:   for(int x=0;x<min.length();x++)
  9:   {
 10:     for(int y=0,z=min.length()-x;z!=min.length+1;y++,z++)
 11:     {
 12:       String temp=min.subString(y,z);
 13:       if(max.contains(temp))
 14:         return temp;
 15:     }
 16:   }
 17: }

StringBuffer类：

StringBuffer是字符串缓冲区，是一个容器。

1.存储：

append( )，返回类型为StringBuffer，将指定的数据作为参数添加到已有数据结尾处。

insert(offset，任意类型)，在offset位置插入一个数据。

toString( )，将StringBuffer中存储的变为字符串

2.删除：

delete(start,end)，删除缓冲区中的数据，包含start，不包含end。

deleteCharAt(index)，删除指定位置的字符。

delete(0,sb.length())，清空缓冲区。

3.获取：

charAt(index)，通过角标获取字符。

indexOf(String str)，通过字符串来获取位置。

lastIndexOf(String str)，反向遍历字符串来获取字符子串的位置。

4.修改：

replace(start,end,str)，将start~end（不包含end）替换成指定的字符串。

setCharAt(index,ch)，将指定index位置的替换成指定的字符ch。

5.反转：

reverse( )

6.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

将缓冲区中的指定数据存储在指定的数组的指定位置中。

  1: 
  2:     StringBuffer sb=new StringBuffer("abcdef");
  3: 
  4:     char[] chs=new char[4];
  5:     sb.getChars(1,4,chs,1);
  6:     for(char c:chs)
  7:     {
  8:       System.out.print(c);
  9:     }
 10:

打印结果为： bcd。

StringBuilder类：

一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步，被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用时，与StringBuffer功能一致。

基本数据类型对象包装类：

<1>基本数据类型转换成字符串：

基本数据类型+“”

基本数据类型.toString( 基本数据类型值)，例如：Integer.toString(34);

<2>字符串转换成基本数据类型：

parseXXXX(str)，例如parseInt(“123”)

Integer类中的toBinaryString()，将十进制转换成二进制。

toHexString()，将十进制转换成十六进制。

toOctalString()，将十进制转换成八进制。

  1: Integer m=128,n=128;
  2: System.out.println("m==n"+(m==n));//false
  3: 
  4: Integer a=127,b=127;
  5: System.out.println("a==b"+(a==b));//true
  6: 
  7: /*
  8: 因为a和b指向了同一个Integer对象，
  9: 因为当数值在byte范围内时，对于新特性，如果该对象已经存在，则不会再开辟新的空间。
 10: byte的范围为：-128~127
 11: */
 12: