StringBuffer特殊吗？

Question

StringBuffer类型是不是特殊的吗，不是和其他对象一样吗他在内存的存放方式有什么不同

Answer 1

不是StringBuffer 特殊 是 String 特殊哦

Answer 2

在java 里面 因为没有指针 所以 对象分为2类 一部分在传递的时候用 引用 一部分 用其copy如 基本类型 和String 都是用copy的

Answer 3

从安全角度上看,String为固定长度可以避免溢出:-)

Answer 4

这样看下
public static void main(String[] arg){
String textString = new String("java");
StringBuffer textBuffer = new StringBuffer("java");
text.replace('j', 'l');
text.append("c");
System.out.println(textString);
System.out.println(textBuffer);
}

Answer 5

这个现象和StringBuffer无关，因为你的函数是static型的，可以内部调用（也可用类名调用或者在别的地方用类名调用），而且内存就为static型的函数和成员分配一个地址，也就是说，不论在那里调用，他的信息就一个，就是刚刚修改的那一个，和对象实例化不一样（有个性，一个实例化对象一个内存地址），严格说他不是面相对象的内容，不过很有用，就这样杂糅进来了。另外，String 是定长的，StringBuffer是变长的，当你处理的字符窗串信息很大，或者可能很大时，可以考虑使用StringBuffer，当存储空间不够时，它会自动变长，别的就没什么了吧！

Answer 6

不好意思！刚才说错了。
我在JDK中找到了大案：
Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared. 我的理解是：String是一个常量，他不能共享，而StringBuffer可以共享，刚才的函数改为
public class Test{
    public static String stringReplace(String text){
        text = text.replace('j', 'l');
        return text;
    }
    public static void bufferReplace(StringBuffer text){
        text= text.append("c");
    }
    public static void main(String[] arg){
        String textString = new String("java");
        StringBuffer textBuffer = new StringBuffer("java");
        textString=stringReplace(textString);
        bufferReplace(textBuffer);
        System.out.println(textString);
        System.out.println(textBuffer);
    }
}就行了。

Answer 7

还是不是很懂，变量的生存期不就是大扩号中吗，而传入函数中的形参和实际参数为什么是一个，按道理应该不是一个函数中的同名的StringBuffer变量和外部的不应该是同一个，那么更改了里边的变量为什么外边的也跟着变了呢。难道静态的变量的生存周期无论什么时候都是存在的吗那他们什么时候才能被销毁呢

Answer 8

其实String和StringBuffer都不是特殊，只是它们对函数的处理不一样StringBuffer tmp = text.append("c");
//这样调用以后，text的值变化了（增加了"c"），tmp和text指向了同一个地址String tmp = text.replace('j', 'l');
//这样调用以后，text的值没有变化，tmp和text指向了两个不同的地址
所以造成了两个不同的结果，这个只是两个方法在实现上不相同的地方，而并不是什么特殊

Answer 9

public static void stringReplace(String text) {
System.out.println("System.identityHashCode(text) = " + System.identityHashCode(text));
text = text.replace('j', 'i');
System.out.println("System.identityHashCode(text) = " + System.identityHashCode(text));
}

Answer 10

public static void bufferReplace(StringBuffer text){
  text= text.append("c");  //这个赋值是没必要的， 只要“text.append("c")”就行
}                          //记住传参是by value， 即使你text=null,也不会影响textBuffer

Answer 11

晕， kevinni 怎么把这么老的帖子翻出来?

Answer 12

出于方便的考虑，我们在进行字符串的内容处理的时候往往会出现以下的代码：
        String result="";
        result+="ok";
这段代码看上去好像没有什么问题，但是需要指出的是其性能很低，原因是java中的String类不可变的（immutable），这段代码实际的工作过程会是如何的呢？通过使用javap工具我们可以知道其实上面的代码在编译成字节码的时候等同的源代码是：
        String result="";
        StringBuffer temp=new StringBuffer();
        temp.append(result);
        temp.append("ok");
        result=temp.toString();
短短的两个语句怎么呢变成这么多呢？问题的原因就在String类的不可变性上，而java程序为了方便简单的字符串使用方式对+操作符进行了重载，而这个重载的处理可能因此误导很多对java中String的使用。//以上是引用http://www.javaresearch.org/article/showarticle.jsp?column=545&thread=752

Answer 13

这是由于String特性所导致的，对于String每次将为其指定一个新的引用。
如 String str = "aaa";
   str +="b";
这段代码的意思是：创建一个"aaa"的String对象。str指向其引用。
                 对于第二句，将会创建一个新的“aaab”String对象，str重指向其引用。
    这时"aaa"将被系统回收，也就是说对于第二句是创建了一个新的对象，而不是原来的引用。这是
和其他对象不一样的地方，一定要注意。而StringBuffer中始终是指向同一个引用，当然会变了。不知道解释清楚没有

Answer 14

public class Test{
public static String  stringReplace(String text){
text = text.replace('j', 'l');
return text;
}
public static void bufferReplace(StringBuffer text){
text= text.append("c");
}
public static void main(String[] arg){
String textString = new String("java");
String Sa="";//
StringBuffer textBuffer = new StringBuffer("java");
Sa=stringReplace(textString);
bufferReplace(textBuffer);
System.out.println(Sa);//
System.out.println(textBuffer);
}
}
把这个运行一下，再加上大家说的应该就明白了。呵呵

Answer 15

晕， kevinni 怎么把这么老的帖子翻出来?
----------------------------------------翻出来是因为正好在 java tutorial中看到了  String  StringBuffer 的比较，
加上前段时间也遇到相同问题 。建议初学者看看java tutorial,
这里有chm版本的下载。
http://www.allimant.org/javadoc/

Answer 16

public class Test{
public static void stringReplace(String text){                 ............1
text = text.replace('j', 'l');                        ............2
}
public static void bufferReplace(StringBuffer text){
text= text.append("c");
}
public static void main(String[] arg){
String textString = new String("java");
StringBuffer textBuffer = new StringBuffer("java");
stringReplace(textString);
bufferReplace(textBuffer);
System.out.print(textString);
System.out.println(textBuffer);
}
}1与2中的text，不是一个对象，甚至2中的text都不是一个对象。在执行text.replace('j', 'l')后创建了一个新的对象，这个对象又赋值给text，这个时候，text已经指向了新的对象。在方法调用完毕后，这个text已经释放，但是传进去的text并没有改变。text.append("c")和text.replace('j', 'l')不一样，他返回的是自己(return this)，他是实实在在把自己给修改了，楼主可以试一试即使text= text.append("c");改为text.append("c")，他仍然会改变上面说的什么String是常量，对，他确实是这样的，但是和这个没有任何关系。考虑下面一种情况void a(int i) {
 i = 0;
}实际上 i没有改变，因为这个i是是在栈里面产生的，上面的text是一样的。text是栈里面的，只是指向了堆上的textString，然后，text.replace('j', 'l')在堆上又创建了一个对象，text又指向了这个新对象，所以textString没有变，只是text指向变了