字符串相关

五、字符串：

1、定义：

    String类适用于描述字符串事物，提供了多个方法对字符串进行操作。

2、String类中的方法：相关练习见StringDemo.java

    (1)获取：
        a、获取长度：
            int length();
        b、根据位置获取某位置上的某个字符：
            char charAt(int index);
        c、根据字符获取该字符串中的位置：
            int indexOf(int ch);//返回ch在字符串中第一次出现的位置
            int indexOf(int ch,int fromIndex);//从fromIndex指定位置开始，获取ch在字符串中出现的位置
            int indexOf(String str);//返回str在字符串中第一次出现的位置
            int indexOf(String str,String fromIndex);//从fromIndex指定位置开始，获取str在字符串中出现的位置
            int lastIndexOf();//反向索引，参数同上
    (2)判断：
        a、字符串中知否包含某一个子串：
            boolean contains(str);
            indexOf也可以用来判断，不存在返回-1
        b、字符串中是否为空：
            boolean isEmpty();
        c、字符串是否以指定内容开头：
            boolean startsWith(str);
        d、字符串是否以指定内容结尾。
            boolean endsWith(str);
        e、判断字符串的内容是否相同，复写了Object类中的equals方法：
            boolean equals(str);
        f、判断内容是否相同，并忽略大小写：
            boolean equalsIgnoreCase();
    (3)转换：
        a、将字符数组转成字符串：
            构造函数：
                String(char[]);
               String(char[],offset,count);//将字符数组中的一部分转成字符串
            静态方法：
                static String copyValueOf(char[] data);
                static String copyValueOf(char[] data,int offset,int count);
        b、将字符串转成字符数组：
            char[] toCharArray();
        c、将字节数组转成字符串
            String(byte[]);
            String(byte[],offset,count);//将字符数组中的一部分转成字符串
        d、将字符串转成字节数组：
            byte[] getBytes();
        e、将基本数据类型转成字符串
            static String valueOf(int);
            static String valueOf(double);
            //3+"";//String.valueOf(3);
            特殊：字符串和字节数组在转换过程中，是可以指定编码表的。 
    (4)替换：
        String replace(oldChar,newChar);
    (5)切割：
        String[] split(regex);
    (6)子串：
        String substring(int beginIndex);
        String substring(int beginIndex,int endIndex);//含头不含尾
    (7)转换、去空格、比较：
        a、将字符串转成大写或小写：
            String toUpperCase();
            String toLowerCase();
        b、将字符串两端的多个空格去除：
            String trim();
        c、对两个字符串进行自然顺序的比较：
            int compareTo(String);

3、StringBuffer类与StringBuilder类(字符串缓冲区)：

    (1)StringBuffer特点：
        a、StringBuffer是一个容器，长度是可变化的。
        b、可以直接操作多种数据类型。
        c、最终会通过toString方法变为字符串。
    (2)用法：
        a、存储：
            StringBuffer append(数据);将指定数据作为参数添加到已有数据结尾处。
            StringBuffer insert(index,数据);可以将数据插入到指定index位置。
        b、删除：
            StringBuffer delete(start,end);删除缓冲区中的数据，包含start不包含end。
            StringBuffer deleteCharAt(index);删除指定位置的字符。
        c、获取：
            char charAt(int index);
            int indexOf(String str);
            int length();
            String substring(int start,int end);
        d、修改：
           StringBuffer replace(start,end,str);
            void setCharAt(index,char);
        e、反转：
            StringBuffer reverse();
    (3)StringBuilder类：
        方法与StringBuffer一样，不过线程不安全，但是效率高于StringBuffer。

        开发时建议使用StringBuilder，多线程时可以自己加锁。

相关代码：

<span style="font-family:Microsoft YaHei;font-size:12px;">/*
关于String操作的小练习
*/
public class StringDemo{

	//练习一：去除字符串两端的空格
	public static String myTrim(String str){
		int start = 0;
		int end = str.length()-1;
		while(start<=end && str.charAt(start)==' ')
			start++;
		while(start<=end && str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);
	}
	
	//练习二：将字符串翻转
	public static String reverseString(String str,int start,int end){//指定起始位置反转
		//字符串转为字符数组
		char[] chs = str.toCharArrary();
		//反转数组
		reverse(chs,start,end);
		//字符数组转为字符串
		return new String(chs);
	}
	public static String reverseString(String str){//全部反转
		reverseString(str,0,str.length());
	}
	private static void reverse(char[] arr,int x,int y){//反转数组函数
		for(int start=x,end=y-1;start<end;start++,end--){//java中取从头到尾一般含头不含尾
			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 int getSubCount(String str,String key){
		int count = 0;
		int index = 0;
		while((index=str.indexOf(key,index))!=-1){
			index = index+key.length();
			count++;
		}
		return count;
	}
	/*
	//方法一：由于每次循环生成一个新字符串，比较消耗内存
	public static int getSubCount(String str,String key){
		int count = 0;
		int index = 0;
		while((index=str.indexOf(key))!=-1){
			str.substring(index+key.length());
			count++;
		}
		return count;
	}
	*/

	//练习四：获取最大长度的相同子串
	/*
	str1:ascadc
	str2:sdc		
	1.temp=sdc  x=0,y=0,z=3
	2.temp=sd	x=1,y=0,z=2
	  temp=dc   x=1,y=1,z=3
	3.temp=s	x=2,y=0,z=1
	  temp=d	x=2,y=1,z=2
	  temp=c	x=2,y=2,z=3
	*/
	public static String getMaxSubString(String str1,String str2){
		String shortStr = (str1.length()<str2.length())?str1:str2;
		String longStr = (str1.length()<str2.length())?str2:str1;
		for(int x=0;x<shortStr.length();x++){
			for(int y=0,z=shortStr.length()-x;z!=shortStr.length()+1;y++,z++){
				String temp = shortStr.substring(y,z);
				if(longStr.contains(temp)){//if(longStr.indexOf(temp)!=-1){
					return temp;
				}
			}
		}
		return "null";
	}	
}</span>