String和StringBuffer

一、String类--java.lang包

1、获取

    1）int length();//获取字符串长度，此处是个方法，而数组的长度是属性
    2）char charAt(int index);//获取角标index处的字符
    3）int indexOf(int ch);//正向索引，返回字符ch第一次出现的角标，如果没有就返回-1
    4）int indexOf(int ch, int fromIndex);//正向索引，返回fromIndex角标开始字符ch第一次出现的角标
    5）int indexOf(String str);//正向索引，返回字符串str第一次出现的角标
    6）int indexOf(Strng str, int fromIndex);//正向索引，返回fromIndex角标开始字符串str第一次出现的角标
    7）int lastIndexOf(int ch);//反向索引，返回字符ch第一次出现的角标
    8）int lastIndexOf(int ch, int fromIndex);//反向索引，返回fromIndex角标开始字符ch第一次出现的角标
    9）int lastIndexOf(String str);//反向索引，返回字符串str第一次出现的角标
    10）int lastIndexOf(String str, int fromIndex);//反向索引，返回fromIndex角标开始字符串str第一次出现的角标

2、判断

    1）boolean isEmpty();//是否是空的
    2）boolean startsWith(String prefix);//是否以特定字符串开头，在文件处理中应用较多
    3）boolean endsWith(String suffix);//是否以特定字符串结尾，在文件处理中应用较多
    4）boolean equals();//是否相等
    5）boolean equaslIgnoreCase();//忽略大小写，判断是否相等。先调用toUpperCase()或者toLowerCase()然后调用equals()方法
    5）boolean contains(CharSequence s);//是否包含某个char值序列。底层调用的是indexOf方法，如果返回值不是-1，那么就包含，返回true，否则返回false

3、转换

    1）字符串转成字符数组
    char[] toCharArray();
    2）字符串转成字节数组
    byte[] getBytes();
    3）字符数组转成字符串
    构造函数：
    String(char[] arr)
    String(char[] arr, int offset, int count)//将arr的offset开始的count长度字符数组转成字符串
    静态函数：
    static String valueOf(char[] arr)
    static String valueOf(char[] arr, int offset, int count)
    该方法可以将基本数据类型转成字符串
    valueOf(int/short/byte/boolean/char[]/double/float/long num)
    static String copyValueOf(char[] arr)
    static String copyValueOf(char[] arr, int offset, int count)

4、替换

    1）void replace(char oldChar, char newChar);//新的字符替换旧的字符
    2）void replace(CharSequence target, CharSequence replacement);//是前面替换后面
    3）void replaceAll(String reex, String replecement)

5、子串  

    String substring(int fromIndex, int toIndex);//返回从fromIndex到toIndex-1的子串

6、切割  

    String[] split(String regex);//使用regex分割
    String[] split(String regex, int limit);//使用正则表达式进行切割
    String[] split(" +");和split("\\s+");//都是用一个或多个空格进行切割

7、小方法

    int compareTo(String s);//返回二者第一个不相同字符的ASCII码的差值
    String toUpperCase();//全部转成大写
    String toLowerCase();//全部转成小写
    String trim();//去除字符串两端的空格

二、StringBuffer/StringBuilder类--java.lang包

    是一个容器，可以看成是缓冲区，长度可变，可以直接操作多个数据类型，最终可以通过toString()方法变成字符串。当输入数据类型不确定，长度也不确定的时候，就使用缓冲区。StringBuilder是1.5版本才出现的，不支持线程同步，效率高，以后还是使用StringBuilder
    java中的升级：
    1）提高安全性能
    2）简化书写
    3）提高效率

方法：

1、增加

    StringBuffer append(boolean/char/double/float/int/long/Object/String/StringBuffer obj)
    增加元素返回的还是这个容器
    StringBuffer append(char[] arr)
    StringBuffer append(char[] arr, int offset, int len)

2、删除

    StringBuffer delete(int fromIndex, int toIndex);//删除fromIndex到toIndex-1
    StringBuffer deleteCharAt(int index);//删除指定角标处的元素

3、修改

    void setCharAt(int index, char ch);//将index处的元素设置为ch

4、插入

    StringBuffer insert(int index, Object/boolean/char/double/float/int/long/String/char[] obj);//在index处插入相应元素

5、获取

    int length();//获取长度
    char charAt(int index);//获取index处的字符
    int indexOf(String str);
    int indexOf(String str, int fromIndex);
    int lastIndexOf(String str);
    int lastIndexOf(String str, int fromIndex);
    void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)
    将srcBegin到srcEnd-1的元素存到字符数组dest的destBegin开始的位置

6、反转

    StringBuffer reverse();

7、转成字符串

    String toString();

8、子串

    String substring(int fromIndex, int toIndex);//获取从fromIndex到toIndex-1的子串

9、替换

    StringBuffer replace(int start, int end, String str);//用str替换start到end-1

代码：

class ReviewString
{
	//去除字符串两端的空格
	public static String myTrim(String s)
	{
		//设置两个指针，一个是从开头遍历，一个是从结尾遍历，直到不是空格，返回子串
		int start = 0, end = s.length()-1;

		//首先要保证start<=end，防止角标越界
		while(start <= end && s.charAt(start) == ' ') 
		{
			start++;
		}
		while(start <= end && s.charAt(end) == ' ')
		{
			end--;
		}

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

	//将字符串进行反转
	public static String strReverse(String s)
	{
		//字符串反转就是将两头的元素进行互换
		//先将字符串转成字符数组
		//然后调用字符数组的反转方法
		char[] arr = s.toCharArray();
		charArrayReverse(arr);

		//将字符数组转成字符串返回
		return new String(arr);
	}

	//字符数组反转方法
	public static void charArrayReverse(char[] arr)
	{
		//字符数组反转就是两头元素进行位置互换
		int start = 0, end = arr.length-1;

		while(start < end)
		{
			swap(arr, start, end);
			start++;
			end--;
		}
	}

	//将字符串特定字段进行反转
	public static String strReverse(String str, int fromIndex, int toIndex)
	{
		//一般都是包含头不包含尾
		//将特定字段进行反转，其实就是将这段内容进行首尾互换
		//将字符串转成字符数组
		char[] arr = str.toCharArray();

		//将字符数组的特定字段进行反转
		charArrayReverse(arr, fromIndex, toIndex);

		//将字符数组变成字符串返回
		return new String(arr);
	}

	//将字符数组特定字段进行反转
	public static void charArrayReverse(char[] arr, int fromIndex, int toIndex)
	{
		//将特定字段首尾互换
		//定义两个指针，一个从fromIndex开始，一个从toIndex-1开始
		int start = fromIndex, end = toIndex-1;

		while(start < end)
		{
			swap(arr, start, end);
			start++;
			end--;
		}
	}

	//交换数组两个元素
	public static void swap(char[] arr, int i, int j)
	{
		char temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	//获取两个字符串中最大的相同子串
	public static String getMaxSubstring(String s1, String s2)	
	{
		//求出两个字符串中较短的字符串，作为参考标准
		String max = (s1.length() > s2.length())? s1: s2;
		String min = (max == s1)? s2: s1;

		//获取较短字符串的子串，判断较长字符串是否包含该子串
		for(int i = 0; i < min.length(); i++)
		{
			for(int j = 0; j < i+1; j++)
			{
				String sub = min.substring(j, j+min.length()-i);
				if(max.contains(sub))
					return sub;
			}
		}

		return null;
	}
	
	//获取一个字符串在另一个字符串中出现的次数
	public static int getCount(String s, String key)
	{
		if(s == null || s.length() == 0|| key == null || key.length() == 0)
			return 0;

		//使用contains只能判断是否存在并不能得到次数
		//因此使用indexOf(String str, int offset)求次数
		//初始化次数
		int count = 0;
		//初始化角标偏移位
		int offset = 0;
		//初始化key出现的角标
		int index = 0;

		while((index = s.indexOf(key, offset)) != -1)
		{
			count++;
			offset = index + key.length();
		}

		return count;
	}
	
	//反转整数
	//比如：321 -> 123, -123 -> -321
	public static int reverseInt(int num)
	{
		//定义num的符号，正数对应1，负数对应-1
		int flag = (num > 0)? 1: -1;
		//求出num的绝对值
		num = Math.abs(num);

		//将int数值转成String
		String s = Integer.toString(num);
		StringBuilder sb = new StringBuilder(s);

		//获取反转整数，为防止溢出，返回long型
		long n = flag * (Long.parseLong(sb.reverse().toString()));

		if(n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
			return (int)n;

		return 0;
	}

	public static void main(String[] args)
	{
		//测试去除字符串两端空格
		String s1 = " I am a student   ";
		System.out.println("("+s1+")去除空格后为："+"("+myTrim(s1)+")");

		//测试反转字符串
		String s2 = "hello, world";
		System.out.println(s2+"反转后是："+strReverse(s2));
		
		//测试字符串特定字段进行反转
		System.out.println(s2+"3~6进行反转后是："+strReverse(s2, 3, 7));

		//测试求两字符串最长子串
		String s3 = "helloworld";
		String s4 = "kklololwd";
		System.out.println(s3+"和"+s4+"最长子串是："+getMaxSubstring(s3, s4));

		//测试一个字符串在另一个字符串中出现的次数
		String s5 = "haaabcalkraajkjaa";
		String key = "aa";
		System.out.println(key+"在"+s5+"中出现的次数为："+getCount(s5, key));

	}
}