一直疑惑，StringBuffer是啥意思呢？
package Demo;
/*
* 十进制-->二进制，4-08
*/
class ArrayTest5 {
public static void toBin(int num)
{
  //新建一个存储字符串StringBuffer的对象sb，？？？？为啥不是String
  StringBuffer sb = new StringBuffer();
  while(num>0)
  {
   sb.append(num%2);
   num = num /2;
  }
  //reverse()翻转功能
  System.out.print(sb.reverse());
}
public static void main(String[] args)
{
  toBin(8);
}
}

StringBuffer是字符串缓冲区，也可以理解为是一个容器。
特点：
1，长度是可变化的。
2，可以字节操作多个数据类型。
3，最终会通过toString方法变成字符串。
它可以对字符串进行存储、删除、获取、修改、反转、以及将缓冲区指定的数据存储到指定的字符数组中
在JDK1.5版本之后出现了StringBuilder.
StringBuffer是线程同步的，在操作数据时不容易错乱但是效率低
而StringBuilder是线程不同步的，效率高，所以开发中建议使用StringBuilder

1. class StringBufferDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //method_update();
   
6. 
   
7.                 StringBuilder sb = new StringBuilder("abcdef");
   
8.         
   
9.                 char[] chs = new char[6];
   
10. 
    
11.                 sb.getChars(1,4,chs,1);//将字符串中1号到4号角标位数据存储到字符数组1号起始位的字符数组中
    
12. 
    
13.                 for(int x=0; x<chs.length; x++)//将得到的字符数组打印
    
14.                 {
    
15.                         sop("chs["+x+"]="+chs[x]+";");
    
16.                 }
    
17. 
    
18.                 draw(3,6);
    
19.                 draw(8,9);
    
20.         }
    
21.         public static void method_update()
    
22.         {
    
23.                 StringBuffer sb  = new StringBuffer("abcde");
    
24. 
    
25.                                  //sb.replace(1,4,"java");//将角标位1到3的数据替换为java
    
26.                 sb.setCharAt(2,'k');//将角标位为2的数据改为k
    
27.                 sop(sb.toString());
    
28.         }
    
29.         public static void method_del()
    
30.         {
    
31.                 StringBuffer sb  = new StringBuffer("abcde");
    
32.                
    
33.              //sb.delete(1,3);//删除角标位1到2的数据
    
34.                 //清空缓冲区。
    
35.                 //sb.delete(0,sb.length());
    
36.                 sb.deleteCharAt(2);//删除指定位置的字符
    
37.                 sop(sb.toString());
    
38.         }
    
39. 
    
40.         public static void method_add()//添加数据
    
41.         {
    
42.                 StringBuffer sb = new StringBuffer();
    
43.                 sb.insert(1,"qq");//将数据添加到指定位置
    
44.                 sop(sb.toString());                        
    
45. }
    
46. 
    
47.         public static void sop(String str)
    
48.         {
    
49.                 System.out.println(str);
    
50.         }
    
51.         
    
52.         public static void draw(int row,int col)
    
53.         {
    
54.                 StringBuilder sb = new StringBuilder();
    
55.                 for(int x=0; x<row; x++)
    
56.                 {
    
57.                         for(int y=0; y<col; y++)
    
58.                         {
    
59.                                 sb.append("*");
    
60.                         }
    
61.                         sb.append("\r\n");
    
62.                 }
    
63.                 sop(sb.toString());
    
64.         }
    
65. }

复制代码

HM刘博 发表于 2013-4-8 07:40
StringBuffer是字符串缓冲区，也可以理解为是一个容器。
特点：
1，长度是可变化的。

StringBuffer是同步的，应该不容易出现安全问题吧,

上楼说得对，StringBuffer线程同步，比较安全，但效率相对低一些
StringBuilder线程不同步，但效率比较高，建议用StringBuilder，如需同步自己加锁

这个是我的学习总结   希望能帮到你

什么是SrtringBuffer？：
StringBuffer是字符串缓冲区。

是一个容器。
特点：
1，长度是可变化的。
2，可以字节操作多个数据类型。
3，最终会通过toString方法变成字符串。

SrtringBuffer类和String类工作原理的对比，以及使用StringBuffer的理由：
  String类用来表示那些创建后就不会再改变的字符串，它是不可变的的。而StringBuffer类用来表示内容可变的字符串，并提供了修改底层字符串的方法。
——当我们进行字符拼接时，请使用StringBuffer类而非String类，因为前者将比后者快上百倍。

的确，在程序的太多场合我们都会进行字符串拼接工作，简单的代码示例如下：
String   str= "You   are   nice. ";
str+= "I   love   you   so   much. ";

如果用StringBuffer类的话，代码如下：
StringBuffer   str=   new   StringBuffer( "You   are   nice. ");
str.append( "I   love   you   so   much. ");

   从表面看来String类只用一个加号（+）便完成了字符串的拼接，而StringBuffer类却要调用一个append()方法，是否实现起来更简洁，更单纯呢？其实不然，让我们了解一下程序运行内部发生了哪些事情：

  经编译后程序的bytecode（字节码）展示出了实质：     在用String类对象直接拼接时，JVM会创建一个临时的StringBuffer类对象，并调用其append()方法完成字符串的拼接，这是因为String类是不可变的，拼接操作不得不使用StringBuffer类（并且－－JVM会将 "You   are   nice. "和 "I   love   you   so   much. "创建为两个新的String对象）。之后，再将这个临时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个临时StringBuffer，和最后将StringBuffer转型成为的String－－它当然不是最初的str了，这个引用的名称没变，但它指向了新的String对象。

  而如果直接使用StringBuffer类，程序将只产生两个对象：最初的StringBuffer和拼接时的String（ "I   love   you   so   much. "），也不再需要创建临时的StringBuffer类对象而后还得将其转换回String对象。

  可以想象，当我们的字符串要被循环拼接若干段时，用String类直接操作会带来多少额外的系统开销，生成多少无用的临时StringBuffer对象，并处理多少次无谓的强制类型转换哪。