今天晚上被讨厌的vba郁闷，以后谁再跟我说vb简单易用我跟谁急。由于计划上每天都要继续讨论java基础语言特性，所以最近也返璞归真，重读thinking in java。发现了一个问题如下：
在第9章 持有你的对象arrays的比较章节，有如此代码片断：
String[] s1 = new String[5];
Arrays.fill(s1,"hi");
String[] s2 = {"hi","hi","hi","hi","hi"};
System.out.println(Arrays.equals(s1,s2));
输出结果true
Bruce给出的解释是s1的所有元素指向同一个对象，s2却拥有5个不同对象，但是Arrays.equals比较的是内容，还特意强调通过Object.equals()，所以结果为true.
首先，我们看看Arryas.fill(s1,"hi")如何工作：
SRC:
public static void fill(Object[] a, Object val) {
fill(a, 0, a.length, val);
}
public static void fill(Object[] a, int fromIndex, int toIndex,Object val){
rangeCheck(a.length, fromIndex, toIndex);
for (int i=fromIndex; i<toIndex; i++)
a[i] = val;
}
显然所有的s1中原素指向了相同的一个对象"hi"这里Bruce没错，那么后面的s2是否拥有5个不同的对象呢？我们做以下代码测试(其中捎带着String类型的测试)
import java.util.Arrays;
public class profit
{
public static void main
(String args
[]){
String s1 =
"Hi";
String s2 =
"Hi";
String s3 =
new String("Hi");
String s4 =
new String("Hi");
if(s1==s2
) System.
out.
println("s1 s2 equal");
if(s3==s4
) System.
out.
println("s3 s4 equal");
//System.out.println(s3.hashCode());
//System.out.println(s4.hashCode());
String[] strArray =
new String[2];
Arrays.
fill(strArray,
"hello");
if(strArray
[0]==strArray
[1]) System.
out.
println("strArray equal");
String[] strArray2 =
{"hello",
"hello"};
if(strArray2
[0]==strArray2
[1]) System.
out.
println("strArray2 equal");
String[] strArray3 =
{new String("hello"),
new String("hello")};
if(strArray3
[0]==strArray
[1]) System.
out.
println("strArray3 equal");
输出结果：
---------- Run ----------
s1 s2 equal
strArray equal
strArray2 equal
Output completed (1 sec consumed) - Normal Termination
首先，各位应该明白最基础的东西 ==实现的比较是浅比较，就是非reference指向的具体对象内容，而是是否指向了同一个对象。第二，String类型被设计为非可变类，就是说 String s1 = "hi";与String s2 = "hi";其实指向了同一个对象，只有用new构造函数的时候才会产生新的对象，而不管内容是否已经在内存中存在。如下文字阐述了一些：
s = new String("Initial Value");
每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同
ok，回到我们的话题上来String[] s2 = {"hi","hi","hi","hi","hi"};是否产生了5个不同的对象呢？我写的简单的测试代码
String[] strArray2 = {"hello","hello"};
if(strArray2[0]==strArray2[1]) System.out.println("strArray2 equal");
的结果大家应该得出了结论了吧。
那么，bruce给出的代码的结果之所以为true就是因为，这么多个数组中的成员"hi"其实都是同一个对象。那么我们继续看Arrays.equals是否比较的内容呢？
SRC：
public static boolean equals(Object[] a, Object[] a2) {
if (a==a2)
return true; //如果指向同一对象，当然是相同的，返回true
if (a==null || a2==null)
return false; //如果为null就没有相等的一说，false
int length = a.length;
if (a2.length != length) //长度不同
return false;
for (int i=0; i<length; i++) {
Object o1 = a[i];
Object o2 = a2[i];
if (!(o1==null ? o2==null : o1.equals(o2))) //此处为关键，object的equals比较，Arrays.equals并没有专门为String类型重载此方法，全部都依赖Object的方法比较
return false;
}
return true;
}
那么我们再看看Object这个树根的equals方法吧：
public boolean equals(Object obj) {
return (this == obj);
}
短短几行代码，但是，是浅比较毫无疑问，所以，bruce说的，依赖的是Object.equals，比较的是内容，更是错误的。
但是必须强调的是，当String数组传递进来的时候，由于java的RTTI执行期型别辨识，Arryas.equals调用的其实是String.equals方法，而String.equals方法是比较内容的，所以，此处我想是bruce没有说明白，而又偏偏列举了String的例子。如果是自己写的类有没有复写equals方法，此时就调用Object.equals了，那么根本不可能比较内容，所以Arrays.equals大家一定要知道怎么回事再用。