尽管在一些特定的场合，由clone()产生的本地副本能够获得我们希望的结果，但程序员（方法的作者）不得不亲自禁止别名处理的副作用。假如想制作一个库，令其具有常规用途，但却不能担保它肯定能在正确的类中得以克隆，这时又该怎么办呢？更有可能的一种情况是，假如我们想让别名发挥积极的作用——禁止不必要的对象复制——但却不希望看到由此造成的副作用，那么又该如何处理呢？
一个办法是创建“不变对象”，令其从属于只读类。可定义一个特殊的类，使其中没有任何方法能造成对象内部状态的改变。在这样的一个类中，别名处理是没有问题的。因为我们只能读取内部状态，所以当多处代码都读取相同的对象时，不会出现任何副作用。
作为“不变对象”一个简单例子，Java的标准库包含了“包装器”（wrapper）类，可用于所有基本数据类型。大家可能已发现了这一点，如果想在一个象Vector（只采用Object引用）这样的集合里保存一个int数值，可以将这个int封装到标准库的Integer类内部。如下所示：
//: ImmutableInteger.java
// The Integer class cannot be changed
import java.util.*;
public class ImmutableInteger {
public static void main(String[] args) {
Vector v = new Vector();
for(int i = 0; i < 10; i++)
v.addElement(new Integer(i));
// But how do you change the int
// inside the Integer?
}
} ///:~Integer类（以及基本的“包装器”类）用简单的形式实现了“不变性”：它们没有提供可以修改对象的方法。
若确实需要一个容纳了基本数据类型的对象，并想对基本数据类型进行修改，就必须亲自创建它们。幸运的是，操作非常简单：
//: MutableInteger.java
// A changeable wrapper class
import java.util.*;
class IntValue {
int n;
IntValue(int x) { n = x; }
public String toString() {
return Integer.toString(n);
}
}
public class MutableInteger {
public static void main(String[] args) {
Vector v = new Vector();
for(int i = 0; i < 10; i++)
v.addElement(new IntValue(i));
System.out.println(v);
for(int i = 0; i < v.size(); i++)
((IntValue)v.elementAt(i)).n++;
System.out.println(v);
}
} ///:~注意n在这里简化了我们的编码。
若默认的初始化为零已经足够（便不需要构造器），而且不用考虑把它打印出来（便不需要toString），那么IntValue甚至还能更加简单。如下所示：
class IntValue { int n; }将元素取出来，再对其进行转换，这多少显得有些笨拙，但那是Vector的问题，不是IntValue的错。
完全可以创建自己的只读类，下面是个简单的例子：
//: Immutable1.java
// Objects that cannot be modified
// are immune to aliasing.
public class Immutable1 {
private int data;
public Immutable1(int initVal) {
data = initVal;
}
public int read() { return data; }
public boolean nonzero() { return data != 0; }
public Immutable1 quadruple() {
return new Immutable1(data * 4);
}
static void f(Immutable1 i1) {
Immutable1 quad = i1.quadruple();
System.out.println("i1 = " + i1.read());
System.out.println("quad = " + quad.read());
}
public static void main(String[] args) {
Immutable1 x = new Immutable1(47);
System.out.println("x = " + x.read());
f(x);
System.out.println("x = " + x.read());
}
} ///:~所有数据都设为private，可以看到没有任何public方法对数据作出修改。事实上，确实需要修改一个对象的方法是quadruple()，但它的作用是新建一个Immutable1对象，初始对象则是原封未动的。
方法f()需要取得一个Immutable1对象，并对其采取不同的操作，而main()的输出显示出没有对x作任何修改。因此，x对象可别名处理许多次，不会造成任何伤害，因为根据Immutable1类的设计，它能保证对象不被改动。
从表面看，不变类的建立似乎是一个好方案。但是，一旦真的需要那种新类型的一个修改的对象，就必须辛苦地进行新对象的创建工作，同时还有可能涉及更频繁的垃圾收集。对有些类来说，这个问题并不是很大。但对其他类来说（比如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) 创建新的不变对象代价太高
请观察下述代码：
//: Stringer.java
public class Stringer {
static String upcase(String s) {
return s.toUpperCase();
}
public static void main(String[] args) {
String q = new String("howdy");
System.out.println(q); // howdy
String qq = upcase(q);
System.out.println(qq); // HOWDY
System.out.println(q); // howdy
}
} ///:~q传递进入upcase()时，它实际是q的引用的一个副本。该引用连接的对象实际只在一个统一的物理位置处。引用四处传递的时候，它的引用会得到复制。
若观察对upcase()的定义，会发现传递进入的引用有一个名字s，而且该名字只有在upcase()执行期间才会存在。upcase()完成后，本地引用s便会消失，而upcase()返回结果——还是原来那个字符串，只是所有字符都变成了大写。当然，它返回的实际是结果的一个引用。但它返回的引用最终是为一个新对象的，同时原来的q并未发生变化。所有这些是如何发生的呢？
(1) 隐式常数
若使用下述语句：
String s = "asdf";
String x = Stringer.upcase(s);那么真的希望upcase()方法改变参数或者参数吗？我们通常是不愿意的，因为作为提供给方法的一种信息，参数一般是拿给代码的读者看的，而不是让他们修改。这是一个相当重要的保证，因为它使代码更易编写和理解。
为了在C++中实现这一保证，需要一个特殊关键字的帮助：const。利用这个关键字，程序员可以保证一个引用（C++叫“指针”或者“引用”）不会被用来修改原始的对象。但这样一来，C++程序员需要用心记住在所有地方都使用const。这显然易使人混淆，也不容易记住。
(2) 重载+和StringBuffer
利用前面提到的技术，String类的对象被设计成“不可变”。若查阅联机文档中关于String类的内容（本章稍后还要总结它），就会发现类中能够修改String的每个方法实际都创建和返回了一个崭新的String对象，新对象里包含了修改过的信息——原来的String是原封未动的。因此，Java里没有与C++的const对应的特性可用来让编译器支持对象的不可变能力。若想获得这一能力，可以自行设置，就象String那样。
由于String对象是不可变的，所以能够根据情况对一个特定的String进行多次别名处理。因为它是只读的，所以一个引用不可能会改变一些会影响其他引用的东西。因此，只读对象可以很好地解决别名问题。
通过修改产生对象的一个崭新版本，似乎可以解决修改对象时的所有问题，就象String那样。但对某些操作来讲，这种方法的效率并不高。一个典型的例子便是为String对象重载的运算符+。“重载”意味着在与一个特定的类使用时，它的含义已发生了变化（用于String的+和+=是Java中能被重载的唯一运算符，Java不允许程序员重载其他任何运算符——注释④）。
④：C++允许程序员随意重载运算符。由于这通常是一个复杂的过程（参见《Thinking in C++》，Prentice-Hall于1995年出版），所以Java的设计者认定它是一种“糟糕”的特性，决定不在Java中采用。但具有讽剌意味的是，运算符的重载在Java中要比在C++中容易得多。
针对String对象使用时，+允许我们将不同的字符串连接起来：
String s = "abc" + foo + "def" + Integer.toString(47);可以想象出它“可能”是如何工作的：字符串"abc"可以有一个方法append()，它新建了一个字符串，其中包含"abc"以及foo的内容；这个新字符串然后再创建另一个新字符串，在其中添加"def"；以此类推。
这一设想是行得通的，但它要求创建大量字符串对象。尽管最终的目的只是获得包含了所有内容的一个新字符串，但中间却要用到大量字符串对象，而且要不断地进行垃圾收集。我怀疑Java的设计者是否先试过种方法（这是软件开发的一个教训——除非自己试试代码，并让某些东西运行起来，否则不可能真正了解系统）。我还怀疑他们是否早就发现这样做获得的性能是不能接受的。
解决的方法是象前面介绍的那样制作一个可变的同志类。对字符串来说，这个同志类叫作StringBuffer，编译器可以自动创建一个StringBuffer，以便计算特定的表达式，特别是面向String对象应用重载过的运算符+和+=时。下面这个例子可以解决这个问题：
//: ImmutableStrings.java
// Demonstrating StringBuffer
public class ImmutableStrings {
public static void main(String[] args) {
String foo = "foo";
String s = "abc" + foo +
"def" + Integer.toString(47);
System.out.println(s);
// The "equivalent" using StringBuffer:
StringBuffer sb =
new StringBuffer("abc"); // Creates String!
sb.append(foo);
sb.append("def"); // Creates String!
sb.append(Integer.toString(47));
System.out.println(sb);
}
} ///:~创建字符串s时，编译器做的工作大致等价于后面使用sb的代码——创建一个StringBuffer，并用append()将新字符直接加入StringBuffer对象（而不是每次都产生新对象）。尽管这样做更有效，但不值得每次都创建象"abc"和"def"这样的引号字符串，编译器会把它们都转换成String对象。所以尽管StringBuffer提供了更高的效率，但会产生比我们希望的多得多的对象。
这里总结一下同时适用于String和StringBuffer的方法，以便对它们相互间的沟通方式有一个印象。这些表格并未把每个单独的方法都包括进去，而是包含了与本次讨论有重要关系的方法。那些已被重载的方法用单独一行总结。
首先总结String类的各种方法：
| 方法 | 参数，重载 | 用途 |
|---|---|---|
| 构造器 | 已被重载 默认，String，StringBuffer，char数组，byte数组 |
创建String对象 |
length() |
无 | String中的字符数量 |
charAt() |
int Index |
位于String内某个位置的char |
getChars()，getBytes |
开始复制的起点和终点，要向其中复制内容的数组，对目标数组的一个索引 | 将char或byte复制到外部数组内部 |
toCharArray() |
无 | 产生一个char[]，其中包含了String内部的字符 |
equals()，equalsIgnoreCase() |
用于对比的一个String | 对两个字符串的内容进行等价性检查 |
compareTo() |
用于对比的一个String |
结果为负、零或正，具体取决于String和参数的字典顺序。注意大写和小写不是相等的！ |
regionMatches() |
这个String以及其他String的位置偏移，以及要比较的区域长度。重载加入了“忽略大小写”的特性 |
一个布尔结果，指出要对比的区域是否相同 |
startsWith() |
可能以它开头的String。重载在参数里加入了偏移 |
一个布尔结果，指出String是否以那个参数开头 |
endsWith() |
可能是这个String后缀的一个String |
一个布尔结果，指出参数是不是一个后缀 |
indexOf(),lastIndexOf() |
已重载：char，char和起始索引，String，String和起始索引 |
|
substring() |
已重载：起始索引，起始索引和结束索引 | 返回一个新的String对象，其中包含了指定的字符子集 |
concat() |
想连结的String |
返回一个新String对象，其中包含了原始String的字符，并在后面加上由参数提供的字符 |
relpace() |
要查找的老字符，要用它替换的新字符 | 返回一个新String对象，其中已完成了替换工作。若没有找到相符的搜索项，就沿用老字符串 |
toLowerCase(),toUpperCase() |
无 | 返回一个新String对象，其中所有字符的大小写形式都进行了统一。若不必修改，则沿用老字符串 |
trim() |
无 | 返回一个新的String对象，头尾空白均已删除。若毋需改动，则沿用老字符串 |
valueOf() |
已重载：object，char[]，char[]和偏移以及计数，boolean，char，int，long，float，double |
返回一个String，其中包含参数的一个字符表现形式 |
Intern() |
无 | 为每个独一无二的字符顺序都产生一个（而且只有一个）String引用 |
可以看到，一旦有必要改变原来的内容，每个String方法都小心地返回了一个新的String对象。另外要注意的一个问题是，若内容不需要改变，则方法只返回指向原来那个String的一个引用。这样做可以节省存储空间和系统开销。
下面列出有关StringBuffer（字符串缓冲）类的方法：
| 方法 | 参数，重载 | 用途 |
|---|---|---|
| 构造器 | 已重载：默认，要创建的缓冲区长度，要根据它创建的String |
新建一个StringBuffer对象 |
toString() |
无 | 根据这个StringBuffer创建一个String |
length() |
无 | StringBuffer中的字符数量 |
capacity() |
无 | 返回目前分配的空间大小 |
ensureCapacity() |
用于表示希望容量的一个整数 | 使StringBuffer容纳至少希望的空间大小 |
setLength() |
用于指示缓冲区内字符串新长度的一个整数 | 缩短或扩充前一个字符串。如果是扩充，则用null值填充空隙 |
charAt() |
表示目标元素所在位置的一个整数 | 返回位于缓冲区指定位置处的char |
setCharAt() |
代表目标元素位置的一个整数以及元素的一个新char值 |
修改指定位置处的值 |
getChars() |
复制的起点和终点，要在其中复制的数组以及目标数组的一个索引 | 将char复制到一个外部数组。和String不同，这里没有getBytes()可供使用 |
append() |
已重载：Object，String，char[]，特定偏移和长度的char[]，boolean，char，int，long，float，double |
将参数转换成一个字符串，并将其追加到当前缓冲区的末尾。若有必要，同时增大缓冲区的长度 |
insert() |
已重载，第一个参数代表开始插入的位置：Object，String，char[]，boolean，char，int，long，float，double |
第二个参数转换成一个字符串，并插入当前缓冲区。插入位置在偏移区域的起点处。若有必要，同时会增大缓冲区的长度 |
reverse() |
无 | 反转缓冲内的字符顺序 |
最常用的一个方法是append()。在计算包含了+和+=运算符的String表达式时，编译器便会用到这个方法。insert()方法采用类似的形式。这两个方法都能对缓冲区进行重要的操作，不需要另建新对象。
现在，大家已知道String类并非仅仅是Java提供的另一个类。String里含有大量特殊的类。通过编译器和特殊的重载或重载运算符+和+=，可将引号字符串转换成一个String。在本章中，大家已见识了剩下的一种特殊情况：用同志StringBuffer精心构造的“不可变”能力，以及编译器中出现的一些有趣现象。