Java常用类：字符串相关类

Java常用类：字符串相关类

String	StringBuffer	StringBuilder
不可变对象，加减操作性能较差	可变对象，字符串加减操作性能好，同步，性能好	可变对象，字符串加减操作性能好，不同步，性能更好

String

方法	内容
charAt(Index)	返回在Index位置上的字符
indexOf(‘C’)/indexOf(“String”)	查找字符C或字符串String所在的位置，-1表示不存在
indexOf(‘C’,n)/indexOf(“String”,n)	从n号位置开始查找字符C或字符串String,-1表示不存在
concat()	在字符串后连接一个新字符串并返回，且旧字符串不变
contains(“String”)	判断是否包含字符串String
endsWith(“String”)	判断是否以字符串String结尾
equals()	比较，返回值为boolean
equalsIgnoreCase()	忽略大小写进行比较，返回值为boolean
length()	返回字符串长度
trim()	返回去除原字符串首尾空格的字符串，但原字符串不变
split()	将字符串按照（？）分割成数组
substring(m)/substring(m,n)	返回从m号位置到末尾的全部内容或m号位置到n号位置之前的所有内容，从0计数
replace(c1,c2)	将字符串中所有的c1都换成c2
replaceAll(c1,c2)	将字符串中所有的c1都换成c2,但是c1位置是个正则表达式，可以实现的不局限于将旧字符串替换为新字符串，还可以将符合情况的字符全部替换
toLowerCase()/toUpperCase()	将字符串中的大写变小写/小写变大写

举下栗子：

public class zxc {
	public static void main(String[] args) {
		String a = "123 4s6 389";
		System.out.println(a.charAt(0)); // 返回第0个元素
		System.out.println(a.indexOf(" ")); // 返回第一个空格的位置
		System.out.println(a.concat(" zxc")); // 连接一个新字符串并返回，a不变
		System.out.println(a);
		System.out.println(a.contains("123")); // 判断a是否包含000
		System.out.println(a.endsWith("9")); // 判断a是否以9结尾
		System.out.println(a.equals("123 4s6 389")); // 判断是否等于123 4s6 789
		System.out.println(a.equalsIgnoreCase("123 4S6 389"));// 判断在忽略大小写情况下是否相等
		System.out.println(a.length()); // 返回a长度
		System.out.println(a.trim()); // 返回a去除前后空格后的字符串，a不变
		String[] b = a.split(" "); // 将a字符串按照空格分割成数组
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
//上一节输出：
//1
//3
//123 4s6 389 zxc
//123 4s6 389
//true
//true
//true
//true
//11
//123 4s6 389
//123	返回的数组
//4s6
//389
		System.out.println(a.substring(2, 5)); // 返回从2号位置到5号位置之前的内容
		System.out.println(a.replace("3", "a"));
		System.out.println(a.replaceAll("3", "a")); // replaceAll第一个参数是正则表达式
	
		String s1 = "12345?6789";
		String s2 = s1.replace("?", "a");
		String s3 = s1.replaceAll("[?]", "a");
		// 这里的[?] 才表示字符问号，这样才能正常替换。不然在正则中会有特殊的意义就会报异常
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s1.replaceAll("[\\d]", "a")); //将s1内所有数字替换为a并输出，s1的值未改变。
		System.out.println(s1);
//上一节输出：
//3 4
//12a 4s6 a89
//12a 4s6 a89
//12345a6789
//12345a6789
//aaaaa?aaaa
//12345?6789
	}
}

StringBuffer和StringBuilder

可变字符串
StringBuffer/StringBuilder： 方法一样，区别在是否同步

方法	内容
append()	在字符串末尾添加
insert(m,“String”)	在字符串m位置插入
delete(m,n)	删除字符串[m,n)位置的内容
replace(m,n,“String”)	替换字符串[m,n)位置的内容为String
substring(m,n)	获取[m,n)位置内容
length()	返回字符串实际大小
capacity()	返回字符串占用空间大小,一般来说capacity>=length
trimToSize()	去除空隙，将字符串存储压缩到实际大小length
setLength()	限制字符串长度，可以扩展也可以收缩
setCharAt(index,‘ch’)	将index位置的字符设为ch,相当于替换

public class zxc {
	public static void main(String[] args) {
		StringBuffer a=new StringBuffer("123");
		//StringBuilder a=new StringBuilder("123");
		System.out.println(a.append("abc"));//在字符串末尾添加abc
		System.out.println(a.insert(3,"-"));//在3的位置插入一个-
		System.out.println(a.delete(3, 4));//删除[3,4)位置的内容
		System.out.println(a.replace(3, 6, "ABC"));//替换[3,6)位置的内容为ABC
		System.out.println(a.substring(3,6));//返回[3,6)位置的内容
		System.out.println(a.capacity());//返回StringBuffer的预留存大小
		a.trimToSize();
		System.out.println(a.capacity());
		System.out.println(a);

		StringBuffer s = new StringBuffer("hello");
        System.out.println(s.length());//5
        s4.setLength(10);//限制字符串长度，可以扩展也可以收缩
        System.out.println(s.length());//10

        s4.setCharAt(3,'k');//将index位置的字符设为k
        System.out.println(s);
	}
}
输出：
123abc
123-abc
123abc
123ABC
ABC
19
6
123ABC
5
10
helko     

测试三种字符串类拼接字符串的速度

StringBuilder>StringBuffer>>>String

import java.util.Calendar;

public class StringAppendTest {

	public static void main(String[] args) {
		int n = 50000;
		Calendar t1 = Calendar.getInstance();
		String a = new String();
		for(int i=0;i<n;i++)
		{
			a = a + i + ",";
		}
		System.out.println("String:");
		System.out.println(Calendar.getInstance().getTimeInMillis() - t1.getTimeInMillis());
		
		Calendar t2 = Calendar.getInstance();
		StringBuffer b = new StringBuffer("");
		for(int i=0;i<n;i++)
		{
			b.append(i);
			b.append(",");
		}
		System.out.println("StringBuffer:");
		System.out.println(Calendar.getInstance().getTimeInMillis() - t2.getTimeInMillis());
		
		Calendar t3 = Calendar.getInstance();
		StringBuilder c = new StringBuilder("");
		for(int i=0;i<n;i++)
		{
			b.append(i);
			b.append(",");
		}
		System.out.println("StringBuilder:");
		System.out.print(Calendar.getInstance().getTimeInMillis() - t3.getTimeInMillis());		
	}
}
输出：
String:
4579
StringBuffer:
11
StringBuilder:
5

测试StringBuffer的预留空间机制

public class StringBufferCapacityTest {
	public static void main(String[] args) {
		//StringBuffer的的初始大小为（16+初始字符串长度）即capacity=16+初始字符串长度
		//length 实际长度  capacity 存储空间大小
		StringBuffer sb1 = new StringBuffer();
		System.out.println("sb1 length: " + sb1.length());
		System.out.println("sb1 capacity: " + sb1.capacity());
		System.out.println("=====================");
//输出：
//sb1 length: 0
//sb1 capacity: 16

		StringBuffer sb2 = new StringBuffer("123");
		sb2.append("456");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
		System.out.println("=====================");
//输出：
//sb2 length: 6
//sb2 capacity: 19	

		sb2.append("7890123456789");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
		System.out.println("=====================");
//输出：
//sb2 length: 19
//sb2 capacity: 19

		sb2.append("0");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
		//一旦length大于capacity时，capacity便在前一次的基础上加1后翻倍；
		System.out.println("=====================");
//输出：
//sb2 length: 20
//sb2 capacity: 40		

		//当前sb2length 20   capacity 40， 再append 70个字符 超过(加1再2倍数额)
		sb2.append("1234567890123456789012345678901234567890123456789012345678901234567890");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
		//如果append的对象很长，超过(加1再2倍数额)，将以最新的长度更换
		System.out.println("=====================");
//输出：
//sb2 length: 90
//sb2 capacity: 90
		
		sb2.append("0");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
		sb2.trimToSize();
//输出：
//sb2 length: 91
//sb2 capacity: 182

		System.out.println("=====after trime================");
		System.out.println("sb2 length: " + sb2.length());
		System.out.println("sb2 capacity: " + sb2.capacity());
//输出;
//b2 length: 91
//sb2 capacity: 91
	}
}