public static boolean equals(
final byte[] left,
int leftOffset,
int leftLen,
final byte[] right,
int rightOffset,
int rightLen) {
// short circuit case
if (left == right && leftOffset == rightOffset && leftLen == rightLen) {
return true;
}
// different lengths fast check
if (leftLen != rightLen) {
return false;
}
if (leftLen == 0) {
return true;
}
// Since we're often comparing adjacent sorted data,
// it's usual to have equal arrays except for the very last byte
// so check that first
if (left[leftOffset + leftLen - 1] != right[rightOffset + rightLen - 1]) return false;
return LexicographicalComparerHolder.BEST_COMPARER.compareTo(
left, leftOffset, leftLen, right, rightOffset, rightLen)
== 0;
}
/** Return true if the byte array on the right is a prefix of the byte array on the left. */
public static boolean startsWith(byte[] bytes, byte[] prefix) {
return bytes != null
&& prefix != null
&& bytes.length >= prefix.length
&& LexicographicalComparerHolder.BEST_COMPARER.compareTo(
bytes, 0, prefix.length, prefix, 0, prefix.length)
== 0;
}
/**
* @param left left operand
* @param right right operand
* @return 0 if equal, < 0 if left is less than right, etc.
*/
public static int compareTo(final byte[] left, final byte[] right) {
return LexicographicalComparerHolder.BEST_COMPARER.compareTo(
left, 0, left.length, right, 0, right.length);
}
/**
* Lexicographically compare two arrays.
*
* @param buffer1 left operand
* @param buffer2 right operand
* @param offset1 Where to start comparing in the left buffer
* @param offset2 Where to start comparing in the right buffer
* @param length1 How much to compare from the left buffer
* @param length2 How much to compare from the right buffer
* @return 0 if equal, < 0 if left is less than right, etc.
*/
public static int compareTo(
byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) {
return LexicographicalComparerHolder.BEST_COMPARER.compareTo(
buffer1, offset1, length1, buffer2, offset2, length2);
}
public static int compareTo(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
return LexicographicalComparerHolder.BEST_COMPARER.compareTo(b1, s1, l1, b2, s2, l2);
}
