Hi,<br><br>Some suggestions:<br><br>1) Any equals*(a, b) methods should support a==null && b==null returning true, only a==null returning -1, and only b==null returning +1. This is very useful for much the same reasons that it's useful in SQL (although the exact ordering of null/non-null is debatable - SQL defaults to "nulls last" but allows you to specify NULLS FIRST, and I agree that its default "nulls first" makes more sense most of the time). This handling of nulls should also extend to any elements of a and b.<br>
<br>2) What the platform REALLY needs is a System.arrayequals(Object src1, int pos1, Object src2, int pos2, int length) that, just like the existing arraycopy(), handles arrays of arbitrary types (that's why src1/src2 are specified as Object). The implementation is trivial (with JNI): just compare the element types, do all the parameter/bound checking and if OK, call memcmp() with the addresses of src1[pos1] and src2[pos2], and length translated to bytes. A better implementation would perform intrinsic compilation. I think the various typed Arrays.equals(a,b) methods already do such optimization (the reason for documentation like: "Unlike the <tt>==</tt> operator, this method considers
 <tt>NaN</tt> equals to itself, and 0.0d unequal to -0.0d."), but these still leave use with the cost of a long case analysis for scenarios like deepEquals() that must handle arrays of arbitrary element-types. IMHO all those typed equals(a,b) should just delegate to a single method, in the System class (not Arrays, not ObjectUtils or whatever), that provides a low-level "raw equals" function. With this low-level (but still safe) function, we can build higher-level APIs like a deepEquals(a,b) with optimum performance. Also, in the current platform there's ByteBuffer.equals() that supports comparison of buffers of arbitrary element types without case analysis, and I guess is also compiled as intrinsic; but I don't want to wrap all my arrays in NIO buffers. The ByteBuffer.equals() should also delegate to the unified System.arrayequals().<br>
<br>A+<br>Osvaldo<br><br><div class="gmail_quote">2009/10/8 Joseph D. Darcy <span dir="ltr"><<a href="mailto:Joe.Darcy@sun.com">Joe.Darcy@sun.com</a>></span><br><blockquote class="gmail_quote" style="margin: 0pt 0pt 0pt 0.8ex; border-left: 1px solid rgb(204, 204, 204); padding-left: 1ex;">
Another piece of functionality requested in the j.u.Objects thread was a deepEquals(Object a, Object b.) method that "did the right thing" if the arguments happened to dynamically be arrays.<br>
<br>
I've been thinking a bit how this might be implemented.<br>
<br>
The array-ness of a and b would need to be determined, after any up-front null-checks<br>
<br>
boolean aIsArray = a.getClass().isArray();<br>
boolean bIsArray = b.getClass().isArray();<br>
<br>
followed various case-analyses.<br>
<br>
if (aIsArray && bIsArray) {<br>
    Class<?> aComponentType = a.getClass().getComponentType();<br>
    Class<?> bComponentType = b.getClass().getComponentType();<br>
   if (aComponentType == bComponentType) {<br>
       // long case analysis to cast and call Arrays.deepEquals if ComponentType is a reference type<br>
       // or the matching Arrays.equals(primitiveComponent[], primitiveComponent[]) method if<br>
       // aComponentType.isPrimitive().<br>
   } else<br>
       return false;<br>
} else<br>
   return a.equals(b);<br>
<br>
Certainly a bit messy internally.<br>
<br>
What are scenarios where this method would be used?<br>
<br>
-Joe<br>
</blockquote></div><br>