浅谈我对JAVA字符串的了解

在JAVA程序里边，我们操作最多的，就是字符串了，字符串可谓是最常见的类了，

打开API文档，在java.lang包下有个String类，下面我来说说该类下常见的字符串操作。

下面演示字符串，常见的方法。

示例：

		String s = "abcdefg";

		/* 下面演示String类常见的方法 */

		/* 获取 */
		s.hashCode();      //获取字符串的哈希码
		s.length();        //获取字符串长度。
		s.charAt(0);       //通过索引，获取字符。
		
		s.indexOf('b');        //通过字符/字符串，获取索引。
		s.indexOf('b',2);      //通过字符/字符串，获取索引。从指定位置开始找。
		s.lastIndexOf('c');    //通过字符/字符串，索取索引，从右往左找。
		s.lastIndexOf('c',5);  //通过字符/字符串，索取索引，从右往左找。

		s.substring(2);        //通过字符串，从给定开始处到结尾处，返回新的字符串。
		s.substring(2,5);      //通过字符串，从给定开始出到指定结尾处-1，返回新的字符串。


		/* 判断 */
		s.contains("d");            //判断字符串是否包含"d"
		s.isEmpty();                //判断字符串是否为空
		s.equals("abc");            //判断字符串是否等于"abc"
		s.equalsIgnoreCase("abc");  //判断字符串是否等于"abc"，忽略大小写
		s.startsWith("a");          //判断字符串开头是否为"a"
		s.endsWith("f");            //判断字符串结尾是否为"f"

		s.compareTo("abcde");       //将字符串转换成ASCLL码，一个一个字符相比较，从左边开始
		                            //返回 负数，零，整数。
					    //零代表两个字符串相等
					    //负数代表当前字符串比较小
					    //整数代表当前字符串比较大
									

	

		/* 转换 */
		s.getBytes();          //将字符串转换成字节数组，
		s.getBytes("utf-8");   //将字符串转换成字节数组，指定编码表
		s.toCharArray();       //将字符串转换成字符数组
		s.toLowerCase();       //将字符串中所有字符都转换成小写
		s.toUpperCase();       //将字符串中所有字符都转换成大写
		s.replace("aa","bb");  //将字符串中的aa,替换成bb
		s.trim();              //删除字符串左右两边的空格


		/* 正则表达式 */

		s.matches("[1][2][3]");    //通过正则表达式，判断是否等于规则
		s.replaceAll("[1]","*");   //通过正则表达式，将字符串所有字符1的转换成*
		s.replaceFirst("x","*");   //通过正则表达式，将字符串左边开始第一个字符为x的转换成*
		s.split(",");              //通过正则表达式，根据给定规则进行拆分字符串
		s.split(",",2);            //通过正则表达式，根据给定规则进行拆分字符串，控制拆分次数
	


		/* 数组间的转换 */ 

		char[] arr1 = {'1','2','3'};
		String s = String.copyValueOf(arr1);      //将字符数组，转换成字符串。
		String s = String.copyValueOf(arr1,1,2);  //将字符数组，转换成字符串。指定开始，结束。

		String s = String.valueOf(Object obj);    //能将所有基本数据类型，转换成字符串。
		String s = String.valueOf(arr1);          //能将字符数组，转换成字符串
		String s = String.valueOf(arr1,1,2);      //能将字符数组，转换成字符串。指定开始，结束。


		String s = new String(arr);               //将字符数组，转换成字符串。
		String s = new String(arr, 1, 2);         //将字符数组，转换成字符串。指定开始，结束。

		byte[] b = {1,2,3,4};
		String s = new String(b);                 //将字节数组，转换成字符串。
		String s = new String(b, 1, 2);           //将字节数组，转换成字符串。指定开始，结束。
		String s = new String(b, "utf-8");        //将字节数组，转换成字符串。指定编码表
		String s = new String(b, 1, 2, "utf-8");  //将字节数组，转换成字符串。指定开始，结束。指定编码表

	}
}

当你对字符串的需求越来越高了，例如你想存储很多基本类型，你可以分段，每次都可以往字符串添加数据，

而你又不想使用连接符，将他们连接一起，麻烦是不是 ?

JAVA就为字符串提供了专门方案 ， 然后字符串缓冲区就诞生了 —— “ StringBuffer ”

StringBuffer类是一个很强大的类，它的强大在于：

1. 长度是可变化的，没有限制字符串的长度
2. 它可以存储多种基本类型

3. 它可以通过toString() 方法，将缓冲区变成字符串

4. 它可以翻转字符串

5. 它可以在指定位置下，插入字符串

这里引用老毕说的一句话 ： 屌就一个字，我只说一次。

下面介绍下StringBuffer的常用功能：

		/* 创建字符串缓冲区 */

		//创建空参数缓冲区，初始容量为 16 个字符。
		StringBuffer sb = new StringBuffer();

		//创建缓冲区，通过字符串定义初始化数据信息
		StringBuffer sb1 = new StringBuffer("abcde");  

		//创建缓冲区，通过缓冲区对象定义初始化数据信息
		StringBuffer sb2 = new StringBuffer(new StringBuffer("12345"));

		//创建缓冲区，并初始容量为 1024 个字符
		StringBuffer sb3 = new StringBuffer(1024);



		/* 存储数据 */

		sb.append(1);                // int 
		sb.append(100000000000000L); // long
		sb.append(1.3f);	     // float 
		sb.append(1.34); 	     // double 
		sb.append(true);	     // boolean 
		sb.append('a'); 	     // char     
		sb.append("abc"); 	     // String

		char[] ch = {'a','b','c'};
		sb.append(ch);              //可以写入字符数组，
		sb.append(ch,1,2);	    //可以写入字符数组，且指定数组开始、结束处。

		sb.insert(2,"qqqqq"); 	    //可以指定索引位置写入数据，该数据可以是任意基本数据类型对象

		sb.append(new StringBuffer("12345"));	//可以写入另一个缓冲区对象。

		
		/* 删除数据 */

		sb.delete(2,5);      //删除数据，指定开始，结束处。
		sb.deleteCharAt(0);  //删除指定位置下的数据。



		/* 获取 */

		sb.length();		   //获取缓冲区长度
		sb.charAt(10);		   //获取索引对应的字符
		sb.indexOf("true");	   //获取字符串对应的索引处，没有返回-1
		sb.lastIndexOf("qq");      //获取字符串对应的索引处，没有返回-1，从右往左遍历
		sb.substring(1,3);	   //获取指定开始，结束处-1的字符串
		sb.toString();		   //获取整个缓冲区的字符串



		/* 转换 */

		sb.replace(0,2,"xxx");  //修改指定开始，结束处-1位置的内容，将其转换成xxx，
		sb.setCharAt(0,'m');    //将索引处的内容，替换成m
		sb.reverse();	        //将字符串就是翻转， 例：ab -> ba

这里要说一下就是 ， JAVA在1.5版本的时候，找了个小弟替代了StringBuffer ， 这个小弟是StringBuilder 。

它们的性质，功能是一样的，它们区别在于：

 StringBuffer  ：线程是同步的，安全的，但是效率低。

StringBuilder ：线程不同步，不安全，但是高效，也就是效率会比StringBuffer高 。

既然是1.5以后出现的版本，那肯定有它的好处，所以，建议是开发使用StringBuilder ~