1.StringBuffer类概述

  StringBuffer类概述：如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个为题。

  线程安全的可变字符序列。

2.线程初识

线程安全，就是线程之间的同步。例如：今天我拿着我的银行卡去取款机取钱，但是同一时刻，我妻子拿着存折去银行取钱。如果银行系统之间的数据是不同步或者说线程之间是不同步，那么，非常happy。我在取款机取了1000元，而我妻子拿着存折在银行也取了1000元。那么，这样的事情，是很“可怕”的。所以，线程安全，就是线程之间的同步，也就意味着数据的安全。

同理，线程不安全，就是线程之间不同步。比如，我在看电视的同时，可以和别人聊天。所以，线程不安全，就是指线程之间不同步，但是不同步也有好处啊，那就是效率高。换句话说，如果线程安全的话，我先看电视，然后看完电视，再和别人说话，这样是能认真的看电视，但是别人可能过了这个时间点都没心情聊天了。

所以，线程安全，即线程之间的同步。和线程不安全，即线程之间的不同步，就是永远困扰我们的问题。就看我们怎么想了，如果你想要数据安全，那么就线程安全，即线程之间的同步；相反，如果你追求高效率的话，那么就线程不安全，即线程之间不同步。

在生活中，线程安全的例子很多，比如：医院的网站和银行的网站。但线程不安全的例子也不少，比如新闻网站，论坛等等。

3.StringBuffer和String之间的区别？

  前者的长度和内容可变，后者不可变。

  如果使用前者做字符串拼接，不会浪费太多的资源。

4.构造方法

public StringBuffer() 

public StringBuffer(CharSequence seq) 

public StringBuffer(int capacity) 

public StringBuffer(String str)

package cn;
/**
 * StringBuffer的构造方法
 * 		public StringBuffer() 无参构造方法
 * 		public StringBuffer(int capacity) 指定容量的字符串缓冲区对象
 * 		public StirngBuffer(String str) 指定字符串内容的字符串缓冲区对象
 *
 * StringBuffer的方法
 * 		public int capacity() 返回当前容量
 * 		public int length() 返回长度 	
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//public StringBuffer() 无参构造方法
		StringBuffer sb = new StringBuffer();
		System.out.println("sb:"+sb);//sb:
		System.out.println("sb的长度："+sb.length());//sb的长度：0
		System.out.println("sb的容量："+sb.capacity());//sb的容量：16
		
		//public StringBuffer(int capacity) 指定容量的字符串缓冲区对象
		StringBuffer sb2 = new StringBuffer(50);
		System.out.println("sb2:"+sb2);//sb2:
		System.out.println("sb2的长度："+sb2.length());//sb2的长度：0
		System.out.println("sb2的容量："+sb2.capacity());//sb2的容量：50
		
		//public StirngBuffer(String str) 指定字符串内容的字符串缓冲区对象
		StringBuffer sb3 = new StringBuffer("helloworld");
		System.out.println("sb3:"+sb3);//sb3:helloworld
		System.out.println("sb3的长度："+sb3.length());//sb3的长度：10
		System.out.println("sb3的容量："+sb3.capacity());//sb3的容量：26
	}

}

5.StringBuffer的增、删、替换、反转功能

StringBuffer类之增功能

package com;
/**
 * StringBuffer的添加功能：
 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面 ，并返回字符串缓冲区本身
 * public StringBuffer insert(int offset,String str):可以将任意类型数据添加到指定字符串缓冲区里面，返回字符串缓冲区本身
 */
public class StringBufferDemo2 {
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		
		//public StringBuffer append(String str):可以把任意类型添加到字符串缓冲区里面 
		StringBuffer sb2 = sb.append("hello");
		System.out.println("sb:"+sb);//sb:hello
		System.out.println("sb2:"+sb2);//sb2:hello
		
		System.out.println(sb == sb2);//true
		
		//append()方法可以调用多次，链式编程
		System.out.println(sb.append("world").append(true).append(‘a‘).append(false));//helloworldtrueafalse
		
		System.out.println(sb.insert(0, "天下无敌"));//天下无敌helloworldtrueafalse
		
	}
}

StringBuffer类之删功能

package com;
/**
 * StringBuffer的删除功能
 * public StringBuffer deleteCharAt(int index) 删除指定位置的字符，并返回字符串缓冲区本身
 * public StringBuffer delete(int strat,int end) 删除从指定位置开始到指定位置结束的内容，并返回字符串缓冲区本身
 *
 */
public class StringBufferDemo3 {
	public static void main(String[] args) {
		//创建对象
		StringBuffer sb = new StringBuffer();
		sb.append("helloworld").append("java");
		System.out.println(sb);//helloworldjava
		
		//public StringBuffer deleteCharAt(int index) 删除指定位置的字符，并返回字符串缓冲区本身
		//需求：要求删除e这个字符，怎么办？
		System.out.println(sb.deleteCharAt(1));//hlloworldjava
		//需求：我要删除第一个l字符,怎么办？
		System.out.println(sb.deleteCharAt(1));//hloworldjava
		
		//public StringBuffer delete(int strat,int end) 删除从指定位置开始到指定位置结束的内容，并返回字符串缓冲区本身
		//需求：我要删除world
		System.out.println(sb.delete(3, 8));//hlojava
		
		//需求：我要删除所有的数据
		System.out.println(sb.delete(0, sb.length()));//
		
	}
	

}

StringBuffer类之替换功能

package com;
/**
 * StringBuffer的替换功能
 * public StringBuffer replace(int start,int end,String str)从strat到end用str替换
 */
public class StringBufferDemo {
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		
		//添加数据
		sb.append("hello").append("world").append("java");
		System.out.println("替换前："+sb);//替换前：helloworldjava
		
		//public StringBuffer replace(int start,int end,String str)从strat到end用str替换
		//需求：把world这个数据用"节日快乐"替换
		sb.replace(5, 10, "节日快乐");
		System.out.println("替换后："+sb);//替换后：hello节日快乐java	
	}
}

StringBuffer类之反转功能

package com;
/**
 * StringBuffer类之反转功能
 * public StringBuffer reverse()
 *
 */
public class StringBufferDemo4 {
	public static void main(String[] args) {
		//定义字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		
		//添加对象
		sb.append("逼傻扬清风");
		
		System.out.println("反转前:"+sb);//反转前:逼傻扬清风
		
		System.out.println("反转后："+sb.reverse());//反转后：风清扬傻逼
		
	}

}

StringBuffer类之截取功能

package com;
/**
 * StringBuffer类之截取功能
 *  public String substring(int start) 
 *  public String substring(int start,int end) 
 *
 */
public class StringDemo6 {
	public static void main(String[] args) {
		//定义一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		
		//添加对象
		sb.append("hello").append("world").append("java");
		System.out.println("截取之前的sb是："+sb);//截取之前的sb是：helloworldjava
		
		//截取功能
		//public String substring(int start)
		String s = sb.substring(5);
		System.out.println("s:"+s);//s:worldjava
		System.out.println("截取之后的sb是："+sb);//截取之后的sb是：helloworldjava		
	}
}

6.StringBuffer和String类的相互转换

package cn;
/**
 *  String和StringBuffer类的相互转换？
 *  String-->StringBuffer的转换：	我们把类A转换为类B，其实是为了使用B的功能。
 *  StringBuffer-->String的转换：	我们可能要的结果是String类型，所以还得转回来
 */
public class StringDemo7 {
	public static void main(String[] args) {
		String s = "hello";
		//不能把字符串的值直接赋值给StringBuffer
		//1.通过构造方法
		StringBuffer sb = new StringBuffer(s);
		System.out.println("String-->StringBuffer："+sb);//String-->StringBuffer：hello
		
		//2.通过append（）方法
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		System.out.println("String-->StringBuffer："+sb2);//String-->StringBuffer：hello
		
		//StringBuffer-->String
		//1.通过toString()方法
		StringBuffer buffer = new StringBuffer("java");
		String str = buffer.toString();
		System.out.println("StringBuffer-->String："+str);//StringBuffer-->String：java
		
		//2.通过String的构造方法
		String str2 = new String(buffer);
		System.out.println("StringBuffer-->String:"+str2);//StringBuffer-->String:java
		
	}
}

7.把数组拼接成一个字符串

package cn;
/**
 * 把数组拼接成一个字符串 
 *
 */
public class StringBufferTest2 {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr = new int[]{44,33,66,33,22};
		
		//方法一：效率低
		//定义功能
		String str = arrayToString(arr);
		
		//拼接后的字符串
		System.out.println("拼接后的字符串："+str);//拼接后的字符串：[44, 33, 66, 33, 22]
		
		//方法二：用StringBuffer。这样效率高
		String str2 = arrayToString2(arr);
		System.out.println("拼接后的字符串："+str2);//拼接后的字符串：[44, 33, 66, 33, 22]
		
	}
	public static String arrayToString2(int[] arr){
		StringBuffer sb = new StringBuffer();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length -1){
				sb.append(arr[i]);
			}else{
				sb.append(arr[i]).append(", ");
			}
		}
		
		
		sb.append("]");
		
		return sb.toString();
	}
	
	
	public static String arrayToString(int[] arr){
		String s = "";
		s += "[";
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length -1){
				s += arr[i];
			}else{
				s += arr[i]+", ";
			}
		}
		s += "]";
		return s;
	}

}

8.字符串反转

package cn;

public class StringBufferTest3 {
	public static void main(String[] args) {
		String s = "我爱你";
		
		//调用方法一
		System.out.println(reverse(s));//你爱我
		
		//调用方法二
		System.out.println(reverse1(s));//你爱我
		
		//但是调用方法一和方法二 就意味着产生很多“垃圾”,所以效率不高，为了提高效率，我们可以先将String转换为StringBuffer,
		//然后调用StringBuffer的reverse()方法，最后再将StringBuffer转换过来
		System.out.println(reverse2(s));//你爱我
		
	}
	/**
	 * 方法一：使用String的length()和charAt()方法
	 * @param s
	 * @return
	 */
	public static String reverse(String s){
		String str = "";
		for (int i = s.length()-1; i >= 0; i--) {
			str += s.charAt(i); 
		}
		return str;
	}
	/**
	 * 方法二：先通过toCharArray()将字符串转换为字符数组，然后将字符数组反转
	 * @param s
	 * @return
	 */
	public static String reverse1(String s){
		char[] chs = s.toCharArray();
		for (int i = chs.length -1,j=0; i > j; i--,j++) {
			char temp = chs[i];
			chs[i] = chs[j];
			chs[j] = temp;
		}
		return  new String(chs);
	}
	/**
	 * 方法三：我们可以先将String转换为StringBuffer
	 * 然后调用StringBuffer的reverse()方法，最后再将StringBuffer转换过来
	 * @param s
	 * @return
	 */
	public static String reverse2(String s){
		return new StringBuffer(s).reverse().toString();
	}
}

9.判断一个字符串是否是对称字符串

package cn;
/**
 * 
 * 需求：判断一个字符串是否是对称 字符串
 *
 */
public class StringBufferTest4 {
	public static void main(String[] args) {
		String str = "abc";
		String str1 = "abba";
		String str2 = "aba";
		
		//调用方法一：
		System.out.println(isSame(str));//false
		System.out.println(isSame(str1));//true
		System.out.println(isSame(str2));//true
		
		
		//调用方法二：
		System.out.println(isSame2(str));//false
		System.out.println(isSame2(str1));//true
		System.out.println(isSame2(str2));//true
	}
	/**
	 * 方法一：先将字符串转换为字符数组，然后对字符数组中的首尾分别判断
	 * @param s
	 * @return
	 */
	public static boolean isSame(String s){
		char[] chs = s.toCharArray();
		for (int i = 0,j=chs.length-1; i < j; i++,j--) {
			if(chs[i] != chs[j]){
				return false;
			}
		}
		return true;
	}
	/**
	 * 方法二：通过将String转换为StringBuffer，然后将其反转后，再将其转换为String，再与原来的String比较
	 * @param s
	 * @return
	 */
	public static boolean isSame2(String s){
		return new StringBuffer(s).reverse().toString().equals(s);
	}
}

10.String、StringBuffer和StringBuilder的区别？

  String是内容不可变得，而StringBuffer和StringBuilder是内容是可变的。

  StringBuffer是数据同步的，是线程安全的，效率低；而StringBuilder是数据不同步的，线程不安全，效率高。

11.StringBuffer和数组的区别？

  二者都可以看成是一个容器，装其他的数组。

  StringBuffer的数组最终是一个字符串数据。

  而数组可以放置多种数组，但必须是同一种数据类型的。

本文出自 “11831428” 博客，请务必保留此出处http://11841428.blog.51cto.com/11831428/1860211

java之StringBuffer类