第十一章 string、stringBuild、stringBuffer

< java.lang >-- final String 字符串：
     java中用String类来描述字符串,并进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作；它是典型的 Immutable 类

如何定义字符串对象呢？String s = “abc”;只要是双引号引起的数据都是字符串对象。

特点：字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中；后续常量池放置在堆中。

(1) String的创建机理
由于String在Java世界中使用过于频繁，Java为了避免在一个系统中产生大量的String对象，引入了字符串常量池。其运行机制是：创建一个字符串时，首先检查池中是否有值相同的字符串对象，如果有则不需要创建直接从池中刚查找到的对象引用；如果没有则新建字符串对象，返回对象引用，并且将新创建的对象放入池中。但是，通过new方法创建的String对象是不检查字符串池的，而是直接在堆区或栈区创建一个新的对象，也不会把对象放入池中。上述原则只适用于通过直接量给String对象引用赋值的情况。

举例：String str1 = "123"; //通过直接量赋值方式，放入字符串常量池
String str2 = new String(“123”);//通过new方式赋值方式，不放入字符串常量池
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true ，字符串中equals比较的是字符串内容是否相同。
注意：String提供了inter()方法。调用该方法时，如果常量池中包括了一个等于此String对象的字符串（由equals方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并且返回此池中对象的引用。

(2) String的特性
[A] 不可变。是指String对象一旦生成，则不能再对它进行改变。不可变的主要作用在于当一个对象需要被多线程共享，并且访问频繁时，可以省略同步和锁等待的时间，从而大幅度提高系统性能。不可变模式是一个可以提高多线程程序的性能，降低多线程程序复杂度的设计模式。
[B] 针对常量池的优化。当2个String对象拥有相同的值时，他们只引用常量池中的同一个拷贝。当同一个字符串反复出现时，这个技术可以大幅度节省内存空间。

字符串的方法：
1：构造方法：将字节数组或者字符数组转成字符串。

		String s1 = new String();//创建了一个空内容的字符串。
		String s2 = null;//s2没有任何对象指向，是一个null常量值。
		String s3 = "";//s3指向一个具体的字符串对象，只不过这个字符串中没有内容。
		//一般在定义字符串时，不用new。
		String s4 = new String("abc");
		String s5 = "abc"; 一般用此写法
		new String(char[]);//将字符数组转成字符串。
		new String(char[],offset,count);//将字符数组中的一部分转成字符串。

2：一般方法：

按照面向对象的思想：
2.1 获取：
2.1.1：获取字符串的长度。length();
2.1.2：指定位置的字符。char charAt(int index);
2.1.3：获取指定字符的位置。如果不存在返回-1，所以可以通过返回值-1来判断某一个字符不存在的情况。
	int indexOf(int ch);//返回第一次找到的字符角标
	int indexOf(int ch,int fromIndex); //返回从指定位置开始第一次找到的角标
	int indexOf(String str); //返回第一次找到的字符串角标
	int indexOf(String str,int fromIndex);
	int lastIndexOf(int ch);
	int lastIndexOf(int ch,int fromIndex);
	int lastIndexOf(String str); 
	int lastIndexOf(String str,int fromIndex);
2.1.4：获取子串。
	String substring(int start);//从start位开始，到length()-1为止.
	String substring(int start,int end);//从start开始到end为止。//包含start位，不包含end位。
	substring(0,str.length());//获取整串
2.2 判断：
2.2.1：字符串中包含指定的字符串吗？
	boolean contains(String substring);
2.2.2：字符串是否以指定字符串开头啊？
	boolean startsWith(string);
2.2.3：字符串是否以指定字符串结尾啊？
	boolean endsWith(string);
2.2.4：判断字符串是否相同
	boolean equals(string);//覆盖了Object中的方法，判断字符串内容是否相同。
2.2.5：判断字符串内容是否相同，忽略大小写。
	boolean equalsIgnoreCase(string) ;
2.3 转换：
2.3.1：通过构造函数可以将字符数组或者字节数组转成字符串。
2.3.2：可以通过字符串中的静态方法，将字符数组转成字符串。
	static String copyValueOf(char[] );
	static String copyValueOf(char[],int offset,int count);
	static String valueOf(char[]);
	static String valueOf(char[],int offset,int count);
2.3.3：将基本数据类型或者对象转成字符串。
	static String valueOf(char);
	static String valueOf(boolean);
	static String valueOf(double);
	static String valueOf(float);
	static String valueOf(int);
	static String valueOf(long);
	static String valueOf(Object);
2.3.4：将字符串转成大小写。
	String toLowerCase();
	String toUpperCase();
2.3.5：将字符串转成数组。
	char[] toCharArray();//转成字符数组。
	byte[] getBytes();//可以加入编码表。转成字节数组。
	
2.3.6：将字符串转成字符串数组。切割方法。
	String[] split(分割的规则-字符串);
	
2.3.7：将字符串进行内容替换。注意：修改后变成新字符串，并不是将原字符串直接修改。
	String replace(oldChar,newChar);	
	String replace(oldstring,newstring);
	
2.3.8： String concat(string); //对字符串进行追加。
	String trim();//去除字符串两端的空格
	int compareTo();//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。

---

–< java.lang >-- StringBuffer 字符串缓冲区：

构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符；StringBuffer 是为解决拼接、裁剪产生太多新的String对象；StringBuffer 本质是一个线程安全的可修改字符序列

特点：
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。

容器通常具备一些固定的方法：
1，添加。

	StringBuffer append(Object obj):在缓冲区中追加数据。追加到尾部。
	StringBuffer insert(index,Object obj):在指定位置插入数据。

2，删除。

	StringBuffer delete(start,end);删除从start至end-1范围的元素
	StringBuffer deleteCharAt(index);删除指定位置的元素
	//sb.delete(0,sb.length());//清空缓冲区。

3，修改。

	StringBuffer replace(start,end,string);将start至end-1替换成此string
	void setCharAt(index,char);替换指定位置的字符
	void setLength(len);将原字符串置为指定长度的字符串

4，查找。（查不到返回-1）

	int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。
	int indexOf(string,int fromIndex);从指定位置开始查找字符串
	int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。
	int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索

5，获取子串。

	string substring(start); 返回start到结尾的子串
	string substring(start,end); 返回start至end-1的子串

6，反转。

	StringBuffer reverse();字符串反转

---

–< java.lang >-- StringBuilder字符串缓冲区：

JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
方法和StringBuffer一样；

StringBuffer和StringBuilder底层都是可修改的(char，jdk9后byte)数组，都是继承了AbstractStringBuilder；

2 StringBuffer/StringBuilder
StringBuffer和StringBuilder都实现了AbstractStringBuilder抽象类，拥有几乎一致对外提供的调用接口；其底层在内存中的存储方式与String相同，都是以一个有序的字符序列（char类型的数组）进行存储，不同点是StringBuffer/StringBuilder对象的值是可以改变的，并且值改变以后，对象引用不会发生改变;两者对象在构造过程中，首先按照默认大小申请一个字符数组，由于会不断加入新数据，当超过默认大小后，会创建一个更大的数组，并将原先的数组内容复制过来，再丢弃旧的数组。因此，对于较大对象的扩容会涉及大量的内存复制操作，如果能够预先评估大小，可提升性能。

唯一需要注意的是：StringBuffer是线程安全的，但是StringBuilder是线程不安全的。可参看Java标准类库的源代码，StringBuffer类中方法定义前面都会有synchronize关键字。为此，StringBuffer的性能要远低于StringBuilder。


3 应用场景	
[A]在字符串内容不经常发生变化的业务场景优先使用String类。例如：常量声明、少量的字符串拼接操作等。如果有大量的字符串内容拼接，避免使用String与String之间的“+”操作，因为这样会产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。
[B]在频繁进行字符串的运算（如拼接、替换、删除等），并且运行在多线程环境下，建议使用StringBuffer，例如XML解析、HTTP参数解析与封装。
[C]在频繁进行字符串的运算（如拼接、替换、删除等），并且运行在单线程环境下，建议使用StringBuilder，例如SQL语句拼装、JSON封装等。

	StringBuilder sb = new StringBuilder("abcdefg");
	sb.append("ak");  //abcdefgak
	sb.insert(1,"et");//aetbcdefgak
	sb.deleteCharAt(2);//aebcdefgak
	sb.delete(2,4);//aedefgak
	sb.setLength(4);//aede
	sb.setCharAt(0,'k');//kede
	sb.replace(0,2,"hhhh");//hhhhe 
	
	//想要使用缓冲区，先要建立对象。
	StringBuffer sb = new StringBuffer();
	sb.append(12).append("haha");//方法调用链。
	String s = "abc"+4+'q';
	s = new StringBuffer().append("abc").append(4).append('q').toString();
---------------------------------------------------------
class  Test
{
	public static void main(String[] args) 
	{
		String s1 = "java";//常量池中不变
		String s2 = "hello";
		method_1(s1,s2);
		System.out.println(s1+"...."+s2); //java....hello
		StringBuilder s11 = new StringBuilder("java");
		StringBuilder s22 = new StringBuilder("hello");
		method_2(s11,s22);
		System.out.println(s11+"-----"+s22); //javahello-----hello
	}
	public static void method_1(String s1,String s2)
	{
		s1.replace('a','k');
		s1 = s2;
	}
	public static void method_2(StringBuilder s1,StringBuilder s2)
	{
		s1.append(s2);
		s1 = s2;
	}

}