string类为什么是immutable(不可变的)

1.什么是不可变的不可变类指的是对象一旦创建成功，就无法改变对象的值。jdk中很多类设计为不可变的Integer,long和string等。相对应的改法中大多是可变类，创建成功后可以动态修改成员变量的属性值；
2.如何保证不可变1>类添加final修饰符，保证类是不可以被继承的；类继承会破坏类的不可变机制，只要覆盖父类的成员方法，并且在里面修改成员变量的值，那么所有子类以父类的形式出现的地方，类的属性都会被修改掉
2>类成员属性设置为private,final的；这样可以保证成员属性是不可变的，但是仅仅这样还不够，因为如果成员变量是引用对象的话，可以改变引用对象的成员变量；通过第四点可以避免这一点；
3>不提供修改成员变量的方法，比如setter；
4>通过构造器构造对象，并进行深拷贝；如果是直接通过引用传入的对象直接赋值给成员，还是可以通过修改外部引用变量导致改变内部变量的值；例如
public class ImmutabloeDemo {
private final int[] myArray;

public ImmutabloeDemo(int[] array) {
this.myArray = array;
}
}这种方式，在外部修改array的值，内部的myArray也会修改了；为了保证外部的修改不会影响内部，可以采用深度clone的方法创建一个新内存来保存传入的值。
public class ImmutabloeDemo {
private final int[] myArray;

public ImmutabloeDemo(int[] array) {
this.myArray = array.clone();
}
}5.同样，在getter方法中，不返回对象本身，只返回对象的克隆。
3.string怎么保证不可变的String对象的源码来看
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];

/** Cache the hash code for the string */
private int hash; // Default to 0

/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;

/**
* Class String is special cased within the Serialization Stream Protocol.
*
* A String instance is written into an ObjectOutputStream according to
* <a href="{@docRoot}/../platform/serialization/spec/output.html">
* Object Serialization Specification, Section 6.2, "Stream Elements"</a>
*/
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];

/**
* Initializes a newly created {@code String} object so that it represents
* an empty character sequence. Note that use of this constructor is
* unnecessary since Strings are immutable.
*/
public String() {
this.value = "".value;
}

/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param original
* A {@code String}
*/
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}

/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
*
* @param value
* The initial value of the string
*/
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}1>String类是finaly的，不允许继承
2.成员变量value是pri
c028
vate,final的
3.value没有setter方法
4.构造方法，是通过克隆的方式来构造的
5.返回value时，通过克隆的方式返回
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}4.string类为不可变对象的好处1>字符串常量池的需要
String one = "someString";
String two = "someString";这两个对象指向同一个内存


字符串常量池的好处是，在大量使用字符串的时候，可以节省内存，提供效率；如果string是可变对象，那么修改了一个，其他引用的地方全部发生变化了。2.线程安全的考虑在并发场景下，多个线程同时读一个资源，不会引发竞争，但是同时写操作会引发竞争，string的不可变特点，所以线程安全的。3.支持hash缓存因为字符串是不可变的，所以创建的时候hash被缓存下来了，不需要重新计算，使得字符串很适合做Map的键，处理速度要快过其他的对象。/** Cache the hash code for the string */
private int hash; // Default to 0
5.String比较一般对象继承子Object类，equals方法使用==来比较对象的地址是否相同，特殊情况下，部分类重写equals方法，比如String对象比较相同时循环数组中每个字符串来判断是否相同的
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}所以
String a1 = new String("haha");
String a2 = new String("haha");
System.out.println(a1 == a2);结果为false，因为new操作会在堆中常见两个对象出来。
而
String one = "someString";
String two = "someString";
System.out.println(one==two);返回结果为true,因为都是常量池中的同一个对象，所以内存地址是一样的
String a = "ABC";
String b = "AB";
String c = b + "C";
System.out.println( a == c );//falsea和b在编译时就确定了，c是变量。
6.string直接赋值和new的区别string str1="ABC"；可能会创建一个对象，也可能不创建对象，如果“ABC”这个字符串在string 池里不存在，就会创建一个对象，然后str1指向这个内存地址，无论以后用这种方式创建多少个值为“ABC”的字符串对象，始终只有一个内存被分配；
string str2 = new String("ABC")；至少创建一个对象，也可能2个；用到new关键字，肯定会在堆中创建一个str2的String 对象，同时如果这个字符串在string池中不存在，会在stirng池中创建一个String对象，值为“ABC”;