Java之String StringBuffer StringBuilder的一些理解

StringBuffer

开发文档显示
线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容为 “start” 的字符串缓冲区对象，则此方法调用 z.append(“le”) 会使字符串缓冲区包含 “startle”，而 z.insert(4, “le”) 将更改字符串缓冲区，使之包含 “starlet”。

通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。

当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。

每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

=========================================================================

StringBuffer 属于lang包下的 故调用的时候不需要导包
要理解一个对象首先明白其构造方法
1.StringBuffer() 初始容量为16字符 表示其是一个容器（不过实际长度跟此无关 ）
2.StringBuffer(CharSequence seq)就是说明任何字符串序列都可以成为其构造参数（多态）
3.StringBuffer(int capacity) 创建指定大小的字符串容器（用的特别少）
4.StringBuffer(String str) 文档说的很好我就不多说了

下面我来解释一下
StringBuffer与String的区别
相同点 在java中都是字符串对象
不同点 StringBuffer是可变序列 而String是不可变的序列（就是一旦String在内存中存在了就不能更改 只能创建新的对象 或弃之） StringBuffer更节省内存空间
其中StringBuffer与String是可以互相转换的

public class Demo6_StringBuffer {

	/**
	 * * A:String -- StringBuffer
		* a:通过构造方法
		* b:通过append()方法
	* B:StringBuffer -- String
		* a:通过构造方法
		* b:通过toString()方法
		* c:通过subString(0,length);

	 */
	public static void main(String[] args) {
		//demo1();
		StringBuffer sb = new StringBuffer("heima");
		
		String s1 = new String(sb);						//通过构造将StringBuffer转换为String
		System.out.println(s1);
		
		String s2 = sb.toString();						//通过toString方法将StringBuffer转换为String
		System.out.println(s2);
		
		String s3 = sb.substring(0, sb.length());		//通过截取子字符串将StringBuffer转换为String
		System.out.println(s3);
	}

	private static void demo1() {
		StringBuffer sb1 = new StringBuffer("heima");			//通过构造方法将字符串转换为StringBuffer对象
		System.out.println(sb1);
		
		StringBuffer sb2 = new StringBuffer();
		sb2.append("heima");									//通过append方法将字符串转换为StringBuffer对象
		System.out.println(sb2);
	}

}

然后介绍一下StringBuffer是一种安全的线程,可同步化不过效率低
而StringBuilder是一种不安全不可同步化的线程 不过效率高
举个列子 ：
上厕所的时候如果门有锁 则进去麻烦不过安全
门没锁的时候 进去不麻烦但是不安全

然后StringBuffer用的比较多的方法
主要是
append 添加
insert 插入
substring 截取
replace 替换
reverse 翻转

关于参数问题其中String有点特殊（虽然是引用数据类型不过其值没有变化）

public class Demo7_StringBuffer {

	/**
	 * * A:形式参数问题
			* String作为参数传递
			* StringBuffer作为参数传递 
		* B:案例演示
			* String和StringBuffer分别作为参数传递问题
			* 
	基本数据类型的值传递,不改变其值
	引用数据类型的值传递,改变其值
	
	String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
	 */
	public static void main(String[] args) {
		String s = "heima";
		System.out.println(s);
		change(s);
		System.out.println(s);
		
		
		System.out.println("---------------------");
		StringBuffer sb = new StringBuffer();
		sb.append("heima");
		System.out.println(sb);
		change(sb);
		System.out.println(sb);
	}

	public static void change(StringBuffer sb) {
		sb.append("itcast");
	}

	public static void change(String s) {
		s += "itcast";
	}

}

打印结果如下

主要是面试用的上（或者参加一些比赛如蓝桥杯）
简单的冒泡排序
时间复杂度 ON^2

public class Main{
	public static void main(String[] args) {
		int arr[] = {51,26,32,45,125,321,12,35};
		bubbleSort(arr);
		print(arr);
	}
	public static void bubbleSort(int[] arr) {
		int temp;
		for(int i=0;i<arr.length-1;i++) {     //n个数 总共比较n-1轮
			for(int j=0;j<arr.length-1-i;j++) {   //然后在每轮 比较n-1-i次 
				if(arr[j]>arr[j+1]) {
					temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
	public static void print(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

选择排序（开发中不用）

public class Main{
	public static void main(String[] args) {
		int arr[] = {51,26,32,45,125,321,12,35};
		//bubbleSort(arr);
		selectSort(arr);
		print(arr);
	}
	public static void bubbleSort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-1-i;j++) {
				if(arr[j]>arr[j+1]) {
					swap(arr,j,j+1);
				}
			}
		}
	}
	//选择排序
	public static void selectSort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					swap(arr,i,j);
				}
			}
		}
	}
	//引用数据类型 数组  通过此来转换 
	public static void swap(int arr[],int i,int j) {
		int temp;
		temp = arr[i] ;
		arr[i] = arr[j];
		arr[j] = temp;
	}
	public static void print(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

二分查找 （查找）
前提 ：数组要有序!
目的 ：查找元素所对应的索引(index)

public class Main{
	public static void main(String[] args) {
		int arr[] = {11,22,33,44,55,66,77,88};
		int index=binarySearch(arr, 22, 0, arr.length-1);
		System.out.println(index);
	}
	//递归二分查找返回索引值   n是指定要找的数
	public static int binarySearch(int[] arr,int n,int min,int max) {
		if(min>max) {
			return -1; //没找到
		}
		int mid = (min+max)/2;
		if(arr[mid]==n) {
			return mid;  //找到了
		}else if(arr[mid]>n){
			return binarySearch(arr, n, min, mid-1);  
		}else {
			return binarySearch(arr, n, mid+1, max);
		}
	}
	/*  0 7 mid=3
	 	0 3 mid=1
	 	0 0 mid=0*/
	 	//循环二分查找返回索引值   n是指定要找的数
	public static int getIndex(int[] arr,int n) {
		int min = 0;
		int max = arr.length-1;
		int mid = (min+max)/2;
		while(arr[mid]!=n) {
			if(arr[mid]>n) {
				max = mid -1;
			}else {
				min = mid +1;
			}
			mid =(min+max)/2;
			if(min>max) {
				return -1;
			}
		}
		return mid;
	}
}

================================================================

系统提供的Arrays类的方法

import java.util.Arrays;
public class Main{
	public static void main(String[] args) {
		int arr[] = {0,51,26,32,45,125,321,12,35};
		Arrays.sort(arr);    //排序
		System.out.println(Arrays.toString(arr));//[0, 12, 26, 32, 35, 45, 51, 125, 321]  打印
		System.out.println("目标索引是"+Arrays.binarySearch(arr, 51));  //二分索引
		print(arr);
	}
	public static void print(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}