[size=large]我一直到今天都不知道什么意思
还有就是String a = new String("sdsd");
为什么是两个对象啊 究竟是哪两个对象啊[size]
不可变性见string的源码 public final class String 可见string 对象是final的
而且字符只要存储在一个char数组里面
private final char value[]; 这个也是final，所以他是不可变的。
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;
if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself. Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off+size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}
this.offset = 0;
this.count = size;
this.value = v;
}
这是string的构造函数，很明显可以看出,"sdsd"是参数也是一个String对象，然后new 了一个string对象a,所以是2个对象。
请问String的"不可变性"和"缓冲池特性"是什么意思是啊?
无非就是要问"String 和 StringBuffer的区别"
这个你google一下 一大堆！！！ 引用一下别人的答案：
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lockedstar/archive/2009/08/24/4480541.aspx
[code="java"]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指向的对象的值已经变了哦
}
}[/code]结果：
STRING类的值是不是会变的->
STRING类的值是不是会变的->
StringBuffer类的值是会变的->加个试试
摘录：
CSDN:
这里的"可变"和"不可变",和是不是final没有关系
举个例子:
[code="java"]String str1 = "hello";
String str2 = "world";
String str1 = str1 + str2;//这里所做的内部操作,其实不是把str1的内容改变为原str1+str2的内容这么简单, 而把创建一个新的String, 内容为str1 + str2的内容,然后再把str1这个引用重新指向新创建的String, 这就是上面说的String不可变. [/code]
而如果是StringBuffer的话,则直接更改str1的内容,而不是先创建一个新的StringBuffer
使用 StringBuffer 主要就是在性能上的考虑。
String 是一种非常常用的数据类型，但由于 String 是不可变对象，在进行 String 的相关操作的时候会产生许多临时的 String 对象。
而 StringBuffer 在操作上是在一个缓冲中进行的，性能当然优越得多。
不过，一般做为简单的字符串传递和其它操作，只不要改变字符串内容的操作，用 String 效率会高一些。
其他
记得以前在网上看到一篇关于java面试题的文章，里面好像有个题就是关于String与StringBuffer的，具体的记不清了，大概内容如下：
请说出下面代码块存在的问题：
[code="java"] String tmp = “”;
for(int i=0;i<n;I++){
tmp +=”x”;
}
[/code] 当时网上有人只是简单的说了要改用StringBuffer，这个存在效率问题，而没有进一步说明，其实我也很郁闷，是什么效率问题呢？“顾名思义，StringBuffer之所以效率好，应该是它提供了缓存机制吧”，我想很多朋友是这样想的吧，HOHO。
当昨天晚上读到Effective java一书的时候，我才恍然大悟，原来String是一个支持非可变性的类，这种类的特点是状态固定(不存在任何修改对象的方法)，在该对象的生存周期内，它的值是永远不变的(它是线程安全的)，它们更容易设计、实现、使用，不易出错，更加安全。
由于String类是支持非可变性的，所以，当执行tmp +=”x”的时候，实际上是另外创建了一个对象，而tmp原来指向的那个对象就成了垃圾(当它没有其它引用的时候)，这样的话一个循环就会产生n多对象，可以相象内存的浪费，怕怕。
先看一下String类中substring方法的实现
[code="java"]public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > count) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == count)) ? this :
new String(offset + beginIndex, endIndex - beginIndex, value);
}
[/code]
从蓝色部份可以看出，它是重新创建了一个新的对象，符合“支持非可变性”的原则，但这却也显示出了非可变类的真正惟一的缺点，就是“对于每一个不同的值都要求一个单独的对象”。
那为什么String要设计成非可变类呢？我觉得String是java中使用最为频繁的一个类，只有使其支持非可变性，才有可能避免一系列的问题，比如说：
[code="java"]String a,b,c;
a=”test”;
b=a;
c=b;
processA(){
……..
}
ProcessB(){
……..
}
ProcessC(){
……..
}
[/code]
当String支持非可变性的时候，它们的值很好确定，不管调用哪个方法，都互不影响，如果它不支持的话，那么我无法想象其结果。
StringBuffer做为String的“配套类(companying class)”，它的作用就是为了解决上述问题的，StringBuffer扮演了String的可变配套类角色。非可变类本质上是线程安全的，它们不要求做同步处理，我们可以将其共享给所有用户，让所有的“客户端程序员”都可以直接使用此类而不需要做任何额外的工作。
[code="java"]public static void main(String[]arg) {
String a ="ssss";
String b = a;
if (a ==b)
System.out.println("a == b");//地址相同
if (a.equals(b))
System.out.println("a equals b");//内容相同
}[/code]
运行结果：
a == b
a equals b
[code="java"]
/* 执行下面这句的时候，会创建一个新的 abcd对象 /
String s1 = "abcd";
/*执行下面这句的时候，会先到字符串缓冲池寻找 abcd 这个对象，如果找到了，引
用该对象，如果没有找到再创建一个新的对象。由于上面第一行已经创建了，所以第二行是直接引用的，没有创建新对象。
/
String s2 = "abcd";
/执行完上面两行，如果紧接着执行下面这句得到的值是true, == 号比较的是内存地址，两个变量引用同一个对象，内存地址当然相同*/
s1 == s2;
/* 下面这两行则是无条件创建两个 abcd 对象，无论缓冲池有没有 abcd这个值 */
String str1 = new String("abcd");
String str2 = new String("abcd");
str1 == str2; //这一行得到的值会是 false,原因两个不同对象内存地址不一样
[/code]
这与JVM内部结构有关。JVM的内存空间分为Stack(栈－存primitive变量值和对象引用)，Heep(堆－存对象)，常量池（存常量），方法区（存对象方法）等等
用双引号引号的字符串是常量——固定不变的，放在常量池中，String str = new String("xxx");创建一个和常量"xxx"字符串相同的String对象，由于是new出来的，所以被存放在堆中,变量str只不过是新创建出来的字符串对象的一个引用，存放在栈中，指向堆中的实际的对象。
建议你先看看JVM Specification，里面有详细说明JVM的内部结构，以运行时内存分部。