javaStringBuffer类

StringBuffer
* 线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。
* 从以下版本开始： JDK1.0
* 父类:Object
* 接口：Serializable, CharSequence
*

import java.util.Arrays;
import java.util.Scanner;

public class Demo {
	public static void main(String[] args) {
		//1：创建一个可变字符序列的缓冲区
		//构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
		/*StringBuffer sb = new StringBuffer();
		//查看容积
		//给缓冲区追加字符串  给容器追加不同类型的值
		sb.append("abc").append(123).append(true).append(10.123).append(new Scanner(System.in));
		System.out.println(sb);
		//容器的容积
		System.out.println("容积："+sb.capacity());
		//字符串的实际长度 
		System.out.println("长度:"+sb.length());*/
		
		// 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
		StringBuffer sb = new StringBuffer("1234");
		System.out.println(sb);
		System.out.println(sb.length());
		System.out.println(sb.capacity());
		
		
		
		
		
	/*	
		int[] arr = new int[5];
		for (int i =1;i<=3;i++) {
			arr = Arrays.copyOf(arr, arr.length+arr.length/2);
			
			System.out.println(arr.length);
		}
		*/
			
	}

}	
	

• StringBuffe的常用的方法
  *
  * 增 append ，insert
  * 删 delete,deleteCharAt
  * 改 setCharAt
  * 查 charAt
  * 容积 capacity();
  * 长度 length
  * 检索 indexOf
  * 替换 replace
  * 反转 reverse
  * 截取 subString
  * 转字符串 toString
  *
  * 面试题：String，StringBuffer，StringBuilder的区别？
  * 1：是否产生新的对象
  * String会产生新的对象，效率低下，浪费内存空间
  * StringBuffer，StringBuilder,不会产生新的对象，都是在原本的缓冲区中操作
  * 2：是否可变
  * String是不可变的
  * StringBuffer，StringBuilder可变的
  * 3：是否安全
  * StringBuffer是安全的
  * StringBuilder是不安全
  * 4：是否多线程
  * StringBuffer适合多线程操作
  * StringBuilder适合单线程操作
  * 5：效率
  * StringBuilder>StringBuffer>String
  *

public class Demo2 {
	public static void main(String[] args) {
		 //1:创建缓冲区
		StringBuffer sb = new StringBuffer();
		 //2:追加数据
		 sb.append("123").append("456").append("789");
		 //3:添加数据  第一个参数：下标  ，第二个参数：插入的数据
		 sb.insert(1, "你好吗");
		// sb.insert(100, "中国");  //超出范围报异常
		 sb.insert(sb.length(), "最后的");
		 sb.append("追加");
		 //4:删除数据  根据下标删除单个字符
		  sb.deleteCharAt(0);
		 //5:删除数据   从起始下标开始删除，到末尾下标结束，但是不包括末尾下标
		 sb.delete(0, 3);
		 //6  修改数据  根据下标修改数据
		 sb.setCharAt(0, '新');
		 //7:查询数据，根据下标查询数据
		 System.out.println(sb.charAt(sb.length()-1));
		 //8:查询子字符串是否在原字符串中，存在返回下标，不存在返回-1
		 System.out.println(sb.indexOf("你好", 0));
		 //9:替换字符  从起始开始替换到默认下标结束，不包含末尾下标
		 System.out.println("原始字符串:"+sb);
		 sb.replace(0, 3, "打家好");
		 System.out.println("替换后的字符串:"+sb);
		 //10：反转字符串
		 System.out.println("原始的字符串:"+sb);
		 sb.reverse();
		 System.out.println("反转后的字符串:"+sb);
		 //11：截取字符串
		 System.out.println("截取的字符串:"+sb.substring(0, 5));
		 System.out.println("截取后的字符串:"+sb);
		
		System.out.println(sb.toString());
			
	}

}

demo

import java.util.Scanner;

public class Demo3 {
	
	/*
	 * ctrl+1 自动匹配类型
	 * 4.判断一个字符串是否为回文。回文是指字符串从左向右读与从右向左读是一样的。
	 */
	public static void method1(){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串，判读是否是回文");
		String s = sc.nextLine();
		//1:将原始字符串放入StringBuffer中
		StringBuffer sb = new StringBuffer(s);
		//2:反转sb
		String newS = sb.reverse().toString();
		//3:判断原始字符串和反转后的字符串
		if(s.equals(newS)){
			System.out.println(s+"是回文");
		}else{
			System.out.println(s+"不是回文");
			
		}
		
	}
	
	/**
	 * 5.消除一个字符串中重复的字符。(本题课堂测试)
	 * 如：已知：how are you ,结果是：how are yu
	 */
	public static void method2(){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串，，消除重复");
		String s = sc.nextLine();
		//1:将原始字符串放入StringBuffer中
		StringBuffer sb = new StringBuffer(s);
		//2:循环StringBuffer
		for(int i = 0;i<sb.length();i++){
			for(int j = 1+i;j<sb.length();j++){
				char ch = sb.charAt(i);
				char ch1 = sb.charAt(j);
				if(ch1==' '){
					continue;
				}
				if(ch == ch1){
					sb.deleteCharAt(j);
					j--;
				}
			}
		}
		
		System.out.println(sb.toString());
		
	}
	
	
	
	public static void main(String[] args) {
		method2();
	}

}

关于这三个类在字符串处理中的位置不言而喻，那么他们到底有什么优缺点，到底什么时候该用谁呢？下面我们从以下几点说明一下

1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String

2.String <（StringBuffer，StringBuilder）的原因

String：字符串常量

StringBuffer：字符创变量

StringBuilder：字符创变量

从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ，比如这段代码：

1 String s = “abcd”;
2 s = s+1;
3 System.out.print(s);// result : abcd1

我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　　　执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：

String str = “This is only a” + “ simple” + “test”;

其实就是：

String str = “This is only a simple test”;

所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

String str2 = “This is only a”;

String str3 = “ simple”;

String str4 = “ test”;

String str1 = str2 +str3 + str4;

这时候JVM会规规矩矩的按照原来的方式去做。

4.StringBuilder与 StringBuffer

StringBuilder：线程非安全的

StringBuffer：线程安全的

当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

对于三者使用的总结：
　　　　　　1.如果要操作少量的数据用 = String
　　　　　　2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
　　　　　　3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer