java string 不变_java中是否存在一成不变的弊端

从表面看，不变类的建立似乎是一个好方案。但是，一旦真的需要那种新类型的一个修改的对象，就必须辛苦地进行新对象的创建工作，同时还有可能涉及更频繁的垃圾收集。对有些类来说，这个问题并不是很大。但对其他类来说(比如String类)，这一方案的代价显得太高了。

为解决这个问题，我们可以创建一个同志类，并使其能够修改。以后只要涉及大量的修改工作，就可换为使用能修改的同志类。完事以后，再切换回不可变的类。

因此，上例可改成下面这个样子：

//: Immutable2.java

// A companion class for making changes

// to immutable objects.

class Mutable {

private int data;

public Mutable(int initVal) {

data = initVal;

}

public Mutable add(int x) {

data += x;

return this;

}

public Mutable multiply(int x) {

data *= x;

return this;

}

public Immutable2 makeImmutable2() {

return new Immutable2(data);

}

}

public class Immutable2 {

private int data;

public Immutable2(int initVal) {

data = initVal;

}

public int read() { return data; }

public boolean nonzero() { return data != 0; }

public Immutable2 add(int x) {

return new Immutable2(data + x);

}

public Immutable2 multiply(int x) {

return new Immutable2(data * x);

}

public Mutable makeMutable() {

return new Mutable(data);

}

public static Immutable2 modify1(Immutable2 y){

Immutable2 val = y.add(12);

val = val.multiply(3);

val = val.add(11);

val = val.multiply(2);

return val;

}

// This produces the same result:

public static Immutable2 modify2(Immutable2 y){

Mutable m = y.makeMutable();

m.add(12).multiply(3).add(11).multiply(2);

return m.makeImmutable2();

}

public static void main(String[] args) {

Immutable2 i2 = new Immutable2(47);

Immutable2 r1 = modify1(i2);

Immutable2 r2 = modify2(i2);

System.out.println("i2 = " + i2.read());

System.out.println("r1 = " + r1.read());

System.out.println("r2 = " + r2.read());

}

} ///:~

和往常一样，Immutable2包含的方法保留了对象不可变的特征，只要涉及修改，就创建新的对象。完成这些操作的是add()和multiply()方法。同志类叫作Mutable，它也含有add()和multiply()方法。但这些方法能够修改Mutable对象，而不是新建一个。除此以外，Mutable的一个方法可用它的数据产生一个Immutable2对象，反之亦然。

两个静态方法modify1()和modify2()揭示出获得同样结果的两种不同方法。在modify1()中，所有工作都是在Immutable2类中完成的，我们可看到在进程中创建了四个新的Immutable2对象(而且每次重新分配了val，前一个对象就成为垃圾)。

在方法modify2()中，可看到它的第一个行动是获取Immutable2 y，然后从中生成一个Mutable(类似于前面对clone()的调用，但这一次创建了一个不同类型的对象)。随后，用Mutable对象进行大量修改操作，同时用不着新建许多对象。最后，它切换回Immutable2。在这里，我们只创建了两个新对象(Mutable和Immutable2的结果)，而不是四个。

这一方法特别适合在下述场合应用：

(1) 需要不可变的对象，而且

(2) 经常需要进行大量修改，或者

(3) 创建新的不变对象代价太高