Java学习笔记（十）String类和StringBuffer类

1. String类和StringBuffer类的区别

（1）String类：创建之后不能再修改和变动的字符串常量

（2）StringBuffer类：创建之后可以修改和变动的字符串变量，即能插入字符，也能追加字符到串尾，StringBuffer类对象的长度是可变的

（3）两个类都被定义为final类型，不能再派生子类。

2. Srting类中的常用方法

equals()方法检查组成的字符串中的内容是否完全一致。注意与“==”的区别，"=="运算符判定两字符串对象是否是同一事例，即它们在内存中的存储空间是否相同。

equalsIgnore()方法忽略大小写方式进行equals比较

toUpperCase()：转化为大写

toLowerCase()：转化为小写

concat()方法向字符串末尾增加字符串

trim()：省略字符串前面的空格和后面的空格，但中间的空格不能去掉。

public int indexOf(int ch)；publicint indexOf(String value);搜索第一个出现的字符或字符串

public int lastIndexOf(int ch); publicint lastIndexOf(String value);搜索最后一个出现的字符或字符串

public String subString(int index);       //提取从位置索引开始的字符串部分

public String subString(intbeginIndex,int endIndex);//提取两者之间的字符串，只包含前者，不包含后者

下面的程序为常用方法的使用：

public class Demo01 {
	public static void main(String[] args) {
		String string = " a.b.c.Java";
		
		 int index = string.indexOf(".");
		 System.out.println("第一个点的位置："+index);
		 
		 int lastIndex = string.lastIndexOf(".");
		 System.out.println("最后一个点的位置："+lastIndex);
		 
		 int index1 = string.indexOf("d"); System.out.println(index1);
		  
		 int index2 = string.indexOf("a.b"); System.out.println(index2);
		 
		 String str1 = string.substring(2); System.out.println(str1);
		  
		 String str2 = string.substring(1,3); System.out.println(str2);
		 
		 String str3 = string.trim(); System.out.println(str3);
		  
		 //取最后一个字符 
		 String str4 = string.substring(string.length() - 2);
		 System.out.println(str4);
		 
		 String fileName = " a.b.c.java";
		// 检查Java的文件名
		int index0 = fileName.lastIndexOf(".");
		
		if (index0 != -1
				&& index0 != 0
				&& fileName.substring(index0 + 1, fileName.length()).equalsIgnoreCase(
						"Java")) {
			Boolean fileCorrect = true;
			System.out.println("输入的文件名为Java");
		} else {
			System.out.println("输入的文件名无效");
		}
	}
}

运行结果为：

第一个点的位置：2
最后一个点的位置：6
-1
1
.b.c.Java
a.
a.b.c.Java
va
输入的文件名为Java

下面的程序演示字符串中split()方法及字符串比较方法的使用：

public class Demo02 {
	public static void main(String[] args) {
		String words = "长亭外|古道边|芳草碧连天|晚风扶|柳笛声残|夕阳山外山";
		String[] printWord = new String[100];
		System.out.println("******原歌词格式******\n" + words
				+ "\n******拆分后歌词格式******");
		printWord = words.split("\\|");
		
		for(String i:printWord){
			System.out.println(i);
		}
		
		String str1 = "abs";
		String str2 = "aas";
		int flag = str1.compareTo(str2);
		if (flag == 0) {
			System.out.println("str1=str2");
		} else if(flag < 0){
			System.out.println("str1<str2");
		}
		else{
			System.out.println("str1>str2");
		}
	}
}

运行结果为：

******原歌词格式******
长亭外|古道边|芳草碧连天|晚风扶|柳笛声残|夕阳山外山
******拆分后歌词格式******
长亭外
古道边
芳草碧连天
晚风扶
柳笛声残
夕阳山外山
str1>str2

3. 字符串的不变性

（1）字符串的不变性——一旦为字符串分配了内存空间，则字符串对应的值不能发生改变。如str+="**"，则相当于又开辟了新的内存空间，原来的指针断开，重新指向新开辟的空间，原来的地址空间就变成了垃圾。因此，忌讳循环中使用字符串的累加。

（2）常量池机制：字符串的不变性机制显然会在String常量内有大量的冗余，JVM留出一段特殊的内存区域，String常量池，定义一个变量时，先在常量池中查找是否存在定义的字符串，如存在，直接将其地址交给变量。

下面的程序说明了equals()和“==”的区别：

public class StringTest {
	public static void main(String[] args) {
		String str1 = "This is the first string";
		String str2 = "This is the first string";
		String str3 = new String("This is the first string");
		String str4 = new String(str1);
		String str5 = str1;
		
		boolean result1 = str1.equals(str2);
		boolean result2 = str1 == str2;
		boolean result3 = str1.equals(str3);
		boolean result4 = str1 == str3;
		boolean result5 = str1.equals(str4);
		boolean result6 = str1 == str4;
		boolean result7 = str1.equals(str5);
		boolean result8 = str1 == str5;
		
		System.out.println("s1 equals s2="+result1);
		System.out.println("s1 == s2="+result2);
		System.out.println("s1 equals s3="+result3);
		System.out.println("s1 == s3="+result4);
		System.out.println("s1 equals s4="+result5);
		System.out.println("s1 == s4="+result6);
		System.out.println("s1 equals s5="+result7);
		System.out.println("s1 == s5="+result8);
	}
}

运行结果为：

s1 equals s2=true
s1 == s2=true
s1 equals s3=true
s1 == s3=false
s1 equals s4=true
s1 == s4=false
s1 equals s5=true
s1 == s5=true

下面的程序演示字符串转化为数组

public class StringToArray {
	public static void main(String[] args) {
		String s = "ABCDE";
		
		//如何把字符串转换为字节数组
		byte b[] = s.getBytes();
		System.out.println("\t"+s);;
		for(int i=0;i<b.length;i++)
			System.out.print("\t"+b[i]);
		System.out.println("");
		
		//如何把字符串转换为字符数组
		char ch[] = s.toCharArray();
		myPrint(ch);
		
		char[] ch1 = new char[3];
		s.getChars(1, 4, ch1, 0);
		myPrint(ch1);
	}
	
	static void myPrint(char[] obj){
		for(int i=0;i<obj.length;i++)
			System.out.print("\t"+obj[i]);
		System.out.println();
	}
}

运行结果为：

ABCDE
65	66	67	68	69
A	B	C	D	E
B	C	D

4. StringBuffer类

（1）系统为String类对象分配内存时，按照对象中所含字符的实际个数等量分配。系统为StringBuffer类对象分配内存时，除去字符所占空间外，再另加16个字符大小的缓冲区

 

（2）StringBuffer类中 length()方法返回的是实际的字符串的长度，capacity()方法返回的是实际的字符串长度加上额外的16个字符大小的空间。

下面的两个程序演示StringBuffer的使用：

public class StringBufferDemo {
	public static void main(String[] args) {
		// String分配内存后就成为常量，无法改变
		String s = new String("This is A String");
		StringBuffer sb = new StringBuffer(s);
		System.out.println("s.length() = "+s.length());
		System.out.println("sb.length()"+sb.length());
		System.out.println("sb.capacity()"+sb.capacity());
		sb.deleteCharAt(8); // 删除指定索引处的值
		sb.insert(8, 'a'); // 在指定索引处增加字符

		int ver = 2;
		sb.insert(sb.length(), "BufferDemo")// 插入一个字符串
				.insert(sb.length(), ver);// 插入一个整型值
		System.out.println(sb.toString());

	}
}

运行结果为：

s.length() = 16
sb.length()16
sb.capacity()32
This is a StringBufferDemo2

public class Demo03 {
	public static void main(String[] args) {
		
		String str1 = "java";
		String str2 = "blog";
		String str3 = str1 + str2;
		System.out.println(str3 == "javablog");
		
		String str4 = "java" + "blog";
		System.out.println(str4 == "javablog");
		
		StringBuffer str = new StringBuffer();
		str.append(str1+str2+str3);
		int nStr = Integer.parseInt("2345", 8);
		nStr = Integer.valueOf("1234").intValue();
		
		System.out.println(str);
		System.out.println(nStr);
		
		StringBuilder strTemp = new StringBuilder();
		strTemp.append("hello");
		strTemp.append(123);
		strTemp.append(true);
		System.out.println(strTemp.toString());
		
	}
}

运行结果为：

false
true
javablogjavablog
1234
hello123true