编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为[1][2][3]的数组形成内容为"1,2,3"的字符串。

我自己写了一个简单的解法:
class testarray
{
        public static void main(String [] args)
        {
                int i;
                int a[]=new int[]{1,2,3};
                for(i=0;i<a.length;i++)
                {
                        System.out.print(a);
                        if(i<a.length-1)
                        {
                                System.out.print(",");               
                        }
       
                }
        }
}
但是老师说最好是用StringBuffer写，这个我不太会用请大家帮忙用StringBuffer写一个我学习下

I 服 U了

这里严禁作业题

晕倒。。。

到网上搜索一下不就好了

呵呵

String的创建

  String s = "hello";
  JVM先根据内容"hello"查找对象，如果没有找到，则在heap上创建新对象，并将其赋予s1，否则使用已经存在的对象

  String s = new String("hello");
  JVM直接在heap上创建新的对象，所以在heap中会出现内容相同，地址不同的String对象


String的比较

  "=="        比较地址
  "equals"    比较内容

  举例:
  String s1 = "hello";
  String s2 = "hello";
  String s3 = new String("hello");

  s1 == s2;               // true        地址相同
  s1 == s3;               // false       地址不同
  s1.equals(s2);          // true        内容相同
  s1.equals(s3);          // true        内容相同


intern() 方法

   查找内容相同(equals())的字符串

   String s1 = "hello";                // hello不存在，jvm创建新对象 (1)
   String s2 = new String("hello");    // 创举新对象 (2)，这时heap中存在两个内容为hello的对象
   s1 == s2;           // false        // 地址不同
   s1.equals(s2);      // true         // 内容相同
   s2 = s2.intern();   // true         // 找到对象(1) 并赋予s2
   s1 == s2;           // true !!      // 注意：此时s1,s2同指向(1)


效率：String 与 StringBuffer

    情景1：
    (1) String result = "hello" + " world";
    (2) StringBuffer result = new String().append("hello").append(" world");

        (1) 的效率好于 (2)，不要奇怪，这是因为JVM会做如下处理
        编译前   String result = "hello" + " world";
        编译后   String result = "hello world";


    情景2：
    (1) public String getString(String s1, String s2) {
            return s1 + s2;
        }
    (2) public String getString(String s1, String s2) {
            return new StringBuffer().append(s1).append(s2);
        }

        (1) 的效率与 (2) 一样，这是因为JVM会做如下处理
        编译前   return s1 + s2;
        编译后   return new StringBuffer().append(s1).append(s2);


    情景3：
    (1) String s = "s1";
              s += "s2";
              s += "s3";
    (2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

        (2) 的效率好于(1)，因为String是不可变对象，每次"+="操作都会造成构造新的String对象


    情景4：
    (1) StringBuffer s = new StringBuffer();
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }
    (2) StringBuffer s = new StringBuffer(250000);
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }
      
        (2) 的效率好于 (1)，因为StringBuffer内部实现是char数组，默认初始化长度为16，每当字符串长度大于char
        数组长度的时候，JVM会构造更大的新数组，并将原先的数组内容复制到新数组，(2)避免了复制数组的开销
        
   


关键点
    1). 简单的认为 .append() 效率好于 "+" 是错误的！
    2). 不要使用 new 创建 String
    3). 注意 .intern() 的使用
    4). 在编译期能够确定字符串值的情况下，使用"+"效率最高
    5). 避免使用 "+=" 来构造字符串
    6). 在声明StringBuffer对象的时候，指定合适的capacity，不要使用默认值(18)
    7). 注意以下二者的区别不一样
        - String s = "a" + "b";
        - String s = "a";
          s += "b";

String 和StringBuffer的区别（JAVA问题）  
String类用来表示那些创建后就不会再改变的字符串，它是immutable的。而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对象，并处理多少次无谓的强制类型转换哪
例子
public class Untitled1 {
  public Untitled1() {
  }
  public static void main(String[] args) {
    Untitled1 untitled11 = new Untitled1();
    String s1="STRING类的值是不是会变的->";
    String s2=s1;
    System.out.println(s2);
    s1+="加个试试"; //String 赋值实际上这个是NEW了一个新的对象了，S1变了
    System.out.println(s2); //S2没有变，这是因为S2指向的地址还是最早的s1所在的地址
   
    StringBuffer b1=new StringBuffer("StringBuffer类的值是会变的->");
    StringBuffer b2=b1;
    b2.append("加个试试");//StringBuffer赋值,操作b2还是那个对象，
    System.out.println(b1);//所以加一个字符进去b1指向的对象的值已经变了哦
  }
}

结果：
STRING类的值是不是会变的->
STRING类的值是不是会变的->
StringBuffer类的值是会变的->加个试试

int[] a=new int[]{1,2,3};
                StringBuffer str=new StringBuffer();
                for(int i=0;i<3;i++)
                        str.append(a+",");

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