jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/Arrays.java

equal deleted inserted replaced

-:ba6a26f39b86
+:6f0bf592d149
 /**
 * Checks that {@code fromIndex} and {@code toIndex} are in
 * the range and throws an exception if they aren't.
 */
-private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
+static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
 if (fromIndex > toIndex) {
 throw new IllegalArgumentException(
 "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
 }
 if (fromIndex < 0) {
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of longs, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of ints are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of ints, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of shorts are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of shorts, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of chars are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of chars, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of bytes are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of bytes, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of booleans are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++)
+return ArraysSupport.mismatch(a, a2, length) < 0;
-if (a[i] != a2[i])
-return false;
-return true;
 }
 /**
 * Returns true if the two specified arrays of booleans, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++)
+return ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++])
+b, bFromIndex,
-return false;
+aLength) < 0;
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of doubles are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++) {
+return ArraysSupport.mismatch(a, a2, length) < 0;
-double v1 = a[i], v2 = a2[i];
-if (Double.doubleToRawLongBits(v1) != Double.doubleToRawLongBits(v2))
-if (!Double.isNaN(v1) || !Double.isNaN(v2))
-return false;
-}
-return true;
 }
 /**
 * Returns true if the two specified arrays of doubles, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++) {
+return ArraysSupport.mismatch(a, aFromIndex,
-Double va = a[aFromIndex++], vb = b[bFromIndex++];
+b, bFromIndex, aLength) < 0;
-if (Double.doubleToRawLongBits(va) != Double.doubleToRawLongBits(vb))
-if (!Double.isNaN(va) || !Double.isNaN(vb))
-return false;
-}
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of floats are
 * <i>equal</i> to one another.  Two arrays are considered equal if both
 int length = a.length;
 if (a2.length != length)
 return false;
-for (int i=0; i<length; i++) {
+return ArraysSupport.mismatch(a, a2, length) < 0;
-float v1 = a[i], v2 = a2[i];
-if (Float.floatToRawIntBits(v1) != Float.floatToRawIntBits(v2))
-if (!Float.isNaN(v1) || !Float.isNaN(v2))
-return false;
-}
-return true;
 }
 /**
 * Returns true if the two specified arrays of floats, over the specified
 * ranges, are <i>equal</i> to one another.
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 if (aLength != bLength)
 return false;
-for (int i = 0; i < aLength; i++) {
+return ArraysSupport.mismatch(a, aFromIndex,
-float va = a[aFromIndex++], vb = b[bFromIndex++];
+b, bFromIndex, aLength) < 0;
-if (Float.floatToRawIntBits(va) != Float.floatToRawIntBits(vb))
-if (!Float.isNaN(va) || !Float.isNaN(vb))
-return false;
-}
-return true;
 }
 /**
 * Returns {@code true} if the two specified arrays of Objects are
 * <i>equal</i> to one another.  The two arrays are considered equal if
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Boolean.compare(a[i], b[i]);
+if (i >= 0) {
+return Boolean.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-boolean va = a[aFromIndex++];
+Math.min(aLength, bLength));
-boolean vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Boolean.compare(va, vb);
+return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Byte.compare(a[i], b[i]);
+if (i >= 0) {
+return Byte.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-byte va = a[aFromIndex++];
+Math.min(aLength, bLength));
-byte vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Byte.compare(va, vb);
+return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Byte.compareUnsigned(a[i], b[i]);
+if (i >= 0) {
+return Byte.compareUnsigned(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-byte va = a[aFromIndex++];
+Math.min(aLength, bLength));
-byte vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Byte.compareUnsigned(va, vb);
+return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Short.compare(a[i], b[i]);
+if (i >= 0) {
+return Short.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-short va = a[aFromIndex++];
+Math.min(aLength, bLength));
-short vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Short.compare(va, vb);
+return Short.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Short.compareUnsigned(a[i], b[i]);
+if (i >= 0) {
+return Short.compareUnsigned(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-short va = a[aFromIndex++];
+Math.min(aLength, bLength));
-short vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Short.compareUnsigned(va, vb);
+return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Character.compare(a[i], b[i]);
+if (i >= 0) {
+return Character.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-char va = a[aFromIndex++];
+Math.min(aLength, bLength));
-char vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Character.compare(va, vb);
+return Character.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Integer.compare(a[i], b[i]);
+if (i >= 0) {
+return Integer.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-int va = a[aFromIndex++];
+Math.min(aLength, bLength));
-int vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Integer.compare(va, vb);
+return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Integer.compareUnsigned(a[i], b[i]);
+if (i >= 0) {
+return Integer.compareUnsigned(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-int va = a[aFromIndex++];
+Math.min(aLength, bLength));
-int vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Integer.compareUnsigned(va, vb);
+return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Long.compare(a[i], b[i]);
+if (i >= 0) {
+return Long.compare(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-long va = a[aFromIndex++];
+Math.min(aLength, bLength));
-long vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Long.compare(va, vb);
+return Long.compare(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-if (a[i] != b[i]) return Long.compareUnsigned(a[i], b[i]);
+if (i >= 0) {
+return Long.compareUnsigned(a[i], b[i]);
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-long va = a[aFromIndex++];
+Math.min(aLength, bLength));
-long vb = b[bFromIndex++];
+if (i >= 0) {
-if (va != vb) return Long.compareUnsigned(va, vb);
+return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-float va = a[i], vb = b[i];
+if (i >= 0) {
-if (Float.floatToRawIntBits(va) != Float.floatToRawIntBits(vb)) {
+return Float.compare(a[i], b[i]);
-int c = Float.compare(va, vb);
-if (c != 0) return c;
-}
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-float va = a[aFromIndex++], vb = b[bFromIndex++];
+Math.min(aLength, bLength));
-if (Float.floatToRawIntBits(va) != Float.floatToRawIntBits(vb)) {
+if (i >= 0) {
-int c = Float.compare(va, vb);
+return Float.compare(a[aFromIndex + i], b[bFromIndex + i]);
-if (c != 0) return c;
-}
 }
 return aLength - bLength;
 }
 if (a == b)
 return 0;
 if (a == null || b == null)
 return a == null ? -1 : 1;
-int length = Math.min(a.length, b.length);
+int i = ArraysSupport.mismatch(a, b,
-for (int i = 0; i < length; i++) {
+Math.min(a.length, b.length));
-double va = a[i], vb = b[i];
+if (i >= 0) {
-if (Double.doubleToRawLongBits(va) != Double.doubleToRawLongBits(vb)) {
+return Double.compare(a[i], b[i]);
-int c = Double.compare(va, vb);
-if (c != 0) return c;
-}
 }
 return a.length - b.length;
 }
 rangeCheck(a.length, aFromIndex, aToIndex);
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
-int length = Math.min(aLength, bLength);
+int i = ArraysSupport.mismatch(a, aFromIndex,
-for (int i = 0; i < length; i++) {
+b, bFromIndex,
-double va = a[aFromIndex++], vb = b[bFromIndex++];
+Math.min(aLength, bLength));
-if (Double.doubleToRawLongBits(va) != Double.doubleToRawLongBits(vb)) {
+if (i >= 0) {
-int c = Double.compare(va, vb);
+return Double.compare(a[aFromIndex + i], b[bFromIndex + i]);
-if (c != 0) return c;
-}
 }
 return aLength - bLength;
 }
 public static int mismatch(boolean[] a, boolean[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code boolean} arrays over the specified ranges, otherwise return -1 if
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch byte
 /**
 public static int mismatch(byte[] a, byte[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code byte} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch char
 /**
 public static int mismatch(char[] a, char[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code char} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch short
 /**
 public static int mismatch(short[] a, short[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code short} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch int
 /**
 public static int mismatch(int[] a, int[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code int} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch long
 /**
 public static int mismatch(long[] a, long[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-if (a[i] != b[i]) return i;
+return (i < 0 && a.length != b.length) ? length : i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code long} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-if (a[aFromIndex++] != b[bFromIndex++]) return i;
+b, bFromIndex,
-}
+length);
+return (i < 0 && aLength != bLength) ? length : i;
-return aLength != bLength ? length : -1;
 }
 // Mismatch float
 /**
 public static int mismatch(float[] a, float[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-float va = a[i], vb = b[i];
+return (i < 0 && a.length != b.length) ? length : i;
-if (Float.floatToRawIntBits(va) != Float.floatToRawIntBits(vb))
-if (!Float.isNaN(va) || !Float.isNaN(vb))
-return i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code float} arrays over the specified ranges, otherwise return -1 if no
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-float va = a[aFromIndex++], vb = b[bFromIndex++];
+b, bFromIndex,
-if (Float.floatToRawIntBits(va) != Float.floatToRawIntBits(vb))
+length);
-if (!Float.isNaN(va) || !Float.isNaN(vb))
+return (i < 0 && aLength != bLength) ? length : i;
-return i;
-}
-return aLength != bLength ? length : -1;
 }
 // Mismatch double
 /**
 public static int mismatch(double[] a, double[] b) {
 int length = Math.min(a.length, b.length); // Check null array refs
 if (a == b)
 return -1;
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, b, length);
-double va = a[i], vb = b[i];
+return (i < 0 && a.length != b.length) ? length : i;
-if (Double.doubleToRawLongBits(va) != Double.doubleToRawLongBits(vb))
-if (!Double.isNaN(va) || !Double.isNaN(vb))
-return i;
-}
-return a.length != b.length ? length : -1;
 }
 /**
 * Finds and returns the relative index of the first mismatch between two
 * {@code double} arrays over the specified ranges, otherwise return -1 if
 rangeCheck(b.length, bFromIndex, bToIndex);
 int aLength = aToIndex - aFromIndex;
 int bLength = bToIndex - bFromIndex;
 int length = Math.min(aLength, bLength);
-for (int i = 0; i < length; i++) {
+int i = ArraysSupport.mismatch(a, aFromIndex,
-double va = a[aFromIndex++], vb = b[bFromIndex++];
+b, bFromIndex,
-if (Double.doubleToRawLongBits(va) != Double.doubleToRawLongBits(vb))
+length);
-if (!Double.isNaN(va) || !Double.isNaN(vb))
+return (i < 0 && aLength != bLength) ? length : i;
-return i;
-}
-return aLength != bLength ? length : -1;
 }
 // Mismatch objects
 /**

changeset 35255	6f0bf592d149
parent 33843	8fdd836f35bc
child 37685	6045bfdd65a5