String、StringBuffer

一、String类

特点：

字符串对象一旦被初始化就不会被改变。

String类的构造函数

            Stirng(byte[ ] bytes)通过使用平台的默认字符集解码指定的byte数组，构造一个新的String。

               String(char[ ] value)分配一个新的String,使其表示字符数组参数中当前包含的字符序列。

            String(char[ ] value，int offset，int count)分配一个新的String，它包含取自字符数组参数一个子数组的字符。

String类部分方法

          1.获取
               1.1 字符串中的包含的字符数，也就是字符串的长度。
                              int length();获取长度。
               1.2 根据位置获取位置上某个字符。
                              char charAt(int index);
               1.3 根据字符获取该字符在字符串中位置。
                              int indexOf(int ch);返回的是ch在字符串中第一次出现的位置。
                              int indexOf(int ch,int fronIndex) ：从fromIndex指定位置开始，获取ch在字符串中出现的位置。
                              int indexOf(String str);返回的是str在字符串中第一次出现的位置。
                              int indexOf(String str,int fronIndex) ：从fromIndex指定位置开始，获取str在字符串中出现的位置。
                              str.lastIndexOf(int ch);

//获取一个字符串在另一个字符串中出现的次数。
class  StringTest2
{   
public static int getSubCount(String str,String key)
{
    int count = 0;
    int index = 0;

    while((index=str.indexOf(key))!=-1)
    {
        sop("str="+str);
        str = str.substring(index+key.length());

        count++;    
    }
    return count;
}

public static int getSubCount_2(String str,String key)
{
    int count = 0;
    int index = 0;

    while((index= str.indexOf(key,index))!=-1)
    {
        sop("index="+index);
        index = index + key.length();

        count++;
    }
    return count;
}
public static void main(String[] args) 
{
    String str = "kkabkkcdkkefkks";
    ///sop("count====="+str.split("kk").length);不建议使用。
    sop("count="+getSubCount_2(str,"kk"));
}
public static void sop(String str)
{
    System.out.println(str);
}
}

2.判断
     2.1 字符串中是否包含某一个子串。
                    boolean contains(str);
                    特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1表示该str不在字符串中存在。
                    所以，也可以用于对指定判断是否包含。
                    if(str.indexOf("aa")!=-1)
                    而且该方法既可以判断，又可以获取出现的位置。
      2.2 字符中是否有内容。
                    boolean isEmpty():原理就是判断长度是否为0.  “” null
      2.3 字符串是否以指定内容开头。
                    boolean startsWith(str);
      2.4 字符串是否以指定内容结尾。
                    boolean endsWith(str);
      2.5 判断字符串内容是否相同，复写了Object类中的equals方法。
                    boolean equals(str);
      2.6 判断内容是否相同，并忽略大小写。
                    boolean equalsIgnoreCase();

3.转换
      3.1 将字符数组转成字符串。
                    构造函数：String(char[])
                                        String(char[],offset,count):将字符数组中的一部分转成字符串。
                    静态方法：
                                        static String copyValueOf(char[]);
                                        static String copyValueOf(char[] data,int offset,int count);
                                        static String copyValueOf(char[]);
     3.2 将字符串转成字符数组。
                   char[] toCharArray();
     3.3 将字节数组转成字符串。
                   String(byte[])
                   String(byte[],offset)
     3.4 将字符串转成字节数组。
                   byte[] getBytes()
     3.5 将基本数据类型转换成字符串。
                   static String valueOf(int)
                   static String valueOf(double)
                   //3+"";//String.valueOf(3);
                   特殊：字符串和直接数组在转换过程中，是可以指定编码表的。

4.替换
           String replace(oldchar,newchar);

5.切割
           String[] split(regex);


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

              String substring(begain);
              String substring(begain,end);

class  StringTest3
{

public static String getMaxSubString(String s1,String s2)
{
    String max = "",min = "";
    max = (s1.length()>s2.length())?s1: s2;
    min = (max==s1)?s2: s1; 
//      sop("max="+max+"...min="+min);
    for(int x=0; x<min.length(); x++)
    {
        for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
        {
            String temp = min.substring(y,z);

            sop(temp);
            if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
                return temp;
        }
    }
    return "";
}
public static void main(String[] args) 
{
    String s1 = "ab";
    String s2 = "cvhellobnm";
    sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
    System.out.println(str);
}
}

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

             7.1 将字符串转成大写或者小写，
                            String toUpperCase();
                            String toLowerCase();
             7.2 将字符串两端的多个空格去除。
                            String trim();
             7.3 对两个字符串进行自然顺序的比较。
                            int compareTo(string);

class StringTest 
{
    public static void sop(String str)
    {
        System.out.println(str);
    }
    public static void main(String[] args) 
    {
        String s = "      ab cd      ";
        sop("("+s+")");
//      s = myTrim(s);
//      sop("("+s+")");
        sop("("+reverseString(s)+")");

    }
    //练习二：将字符串反转。
    /*
    思路：
    1，将字符串变成数组。
    2，对数组反转。
    3，将数组变成字符串。
    */
    public static String reverseString(String s,int start,int end)
    {
        //字符串变数组。
        char[] chs = s.toCharArray();
        //反转数组。
        reverse(chs,start,end);
        //将数组变成字符串。
        return new String(chs);
    }
    public static String reverseString(String s)
    {
        return reverseString(s,0,s.length());       
    }
    private static void reverse(char[] arr,int x,int y)
    {
        for(int start=x,end=y-1; start<end ; start++,end--)
        {
            swap(arr,start,end);
        }
    }
    private static void swap(char[] arr,int x,int y)
    {
        char temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
    //练习一，去除字符串两端空格。
    public static String myTrim(String str)
    {
        int start = 0,end = str.length()-1;

        while(start<=end && str.charAt(start)==' ')
            start++;

        while(start<=end && str.charAt(end)==' ')
            end--;

        return str.substring(start,end+1);
    }
}

二、StringBuffer

StringBuffer：就是字符串缓冲区，用于存储数据的容器。

特点：
        1. 长度是可变的。
        2. 可以存储不同类型数据。
        3. 最终要转成字符串进行使用。

常用的操作方法

        1.存储
                   StringBuffer append();将指定数据作为参数添加到该已有数据的结尾处。
                   StringBuffer insert(index,数据)：可以将数据插入到指定index位置。

        2.删除
                   StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
                   StringBuffer deleteChatAt(index):删除指定位置的字符。

        3.获取
                   char chaAt(int index)
                   int indexOf(String str) 
                   int lastIndexOf(String str)
                   int length()
                   String subString(int start,int end)

        4.修改
                  StringBuffer replace(start,end,string);
                  void setCharAt(int index,char ch);

        5.反转
                   StringBuffer reverse();

        6.将缓冲区中指定数据存储到指定字符数组中。
                   void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

JDK1.5版本之后出现了StringBuilder。

StringBuffer是线程同步。
StringBuilder是线程不同步。

以后开发，建议使用StringBulider

升级三个因素：
       1.提高效率
       2.简化书写
       3.提高安全性

class StringBuilderTest{
  public static void main(String[] args){
	int[] arr = {3,1,5,4,8};
	String s = arrayToString(arr);

	 System.out.println(s);
  }

  public static String arrayToString(int[] arr){
	StringBuilder sb = new StringBuilder();
	sb.append( "[");
	for(int i = 0; i < arr.length; i++){
		if(i != arr.length - 1)
			sb.append(arr[i]).append( ",");
		else
			sb.append(arr[i]).append( "]");
	}
	return sb.toString();
  }
}

基本数据类型对象包装类

        为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

byte                 Byte
short                Short
int                    Integer
long                 Long
float                 Float
double            Double
char                Character
boolean          Boolean

基本数据类型对象包装类的最常见作用。就是用于基本数据类型和字符串类型之间做转换


基本数据类型转成字符串

        基本数据类型+""
        基本数据类型.toString(基本数据类型值)
                如：Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型

         xxx a = xxx.parsexxx(String);
         int a = Integer.parseInt("123");
         double b = Double.parseDouble("12.23"); 
         boolean b = Boolean,parseBoolean("true");

十进制转成其他进制
         toBinaryString();
         toHexString();
         toOctalString();

其他进制转成十进制
         parseInt(String,radix);

class  IntegerDemo
{
	public static void main(String[] args) 
	{
		int num = Integer.parseInt("123");

		sop("num="+(num+4));
		sop(Integer.toBinaryString(-6));
		int x = Integer.parseInt("110",2);
	}

		public static void sop(String str)
	{
		System.out.println(str);
	}
}

JDK1.5版本以后出现的新特性

        1.Integer x=4；//自动装箱；等同于Integer x=new Integer(4); 
        2.x=x+2;//x+2：x进行自动拆箱，变成了int类型和2进行加法运算，在将和进行装箱赋给x；

    3.Integer m=128;Integer n=128; m==n;//false; 

       4.Integer a=127; Integer b=127; a==b;//true; 
        解释：因为a和b指向了同一个Integer对象，所以为true；因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间；