String类，StringBuffer类，StringBuilder类，基本数据类型对象包装类

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: