lucene工具类FutureArrays

lucene7.x 引入，数组处理工具类。方法大多与与jdk 9 中Arrays的方法相同。在java 8的环境下，lucene仍然使用此类。当lucene的后续发行版本最低要求使用jdk9时，该类将移除，直接使用jdk9的Arrays类,功能一致。

equals判断两个byte数组

  /**
   * Behaves like Java 9's Arrays.equals
   * @see <a href="http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html#equals-byte:A-int-int-byte:A-int-int-">Arrays.equals</a>
   */
   //比较两个字节数组，从fromIndex到toIndex的范围内是否相等
  public static boolean equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    // lengths differ: cannot be equal
    if (aLen != bLen) {
      return false;
    }
    for (int i = 0; i < aLen; i++) {
      if (a[i+aFromIndex] != b[i+bFromIndex]) {
        return false;
      }
    }
    return true;
  }

equals判断两个char数组

  /**
   * Behaves like Java 9's Arrays.equals
   * @see <a href="http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html#equals-char:A-int-int-char:A-int-int-">Arrays.equals</a>
   */
  public static boolean equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    // lengths differ: cannot be equal
    if (aLen != bLen) {
      return false;
    }
    for (int i = 0; i < aLen; i++) {
      if (a[i+aFromIndex] != b[i+bFromIndex]) {
        return false;
      }
    }
    return true;
  }

equals判断两个int数组

  /**
   * Behaves like Java 9's Arrays.equals
   * @see <a href="http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html#equals-int:A-int-int-int:A-int-int-">Arrays.equals</a>
   */
  public static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    // lengths differ: cannot be equal
    if (aLen != bLen) {
      return false;
    }
    for (int i = 0; i < aLen; i++) {
      if (a[i+aFromIndex] != b[i+bFromIndex]) {
        return false;
      }
    }
    return true;
  }

equals判断两个long数组

   /**
   * Behaves like Java 9's Arrays.equals
   * @see <a href="http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html#equals-long:A-int-int-long:A-int-int-">Arrays.equals</a>
   */
  public static boolean equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    // lengths differ: cannot be equal
    if (aLen != bLen) {
      return false;
    }
    for (int i = 0; i < aLen; i++) {
      if (a[i+aFromIndex] != b[i+bFromIndex]) {
        return false;
      }
    }
    return true;
  }

compare比较两个long数组

  /**
   * Behaves like Java 9's Arrays.compare
   * @see <a href="http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html#compare-long:A-int-int-long:A-int-int-">Arrays.compare</a>
   */
  public static int compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    int len = Math.min(aLen, bLen);
    // 公共范围内，比较相同的相对位置上谁大
    for (int i = 0; i < len; i++) {
      long aInt = a[i+aFromIndex];
      long bInt = b[i+bFromIndex];
      if (aInt > bInt) {
        return 1;
      } else if (aInt < bInt) {
        return -1;
      }
    }
	// len长度范围内一致，比较两个数组谁长
    // One is a prefix of the other, or, they are equal:
    return aLen - bLen;
  }

compareUnsigned

  // 比较两个字节数组，若a数组比b数组相同位置的元素大(不考虑符号,通过byte &0xFF)，则返回差值；
  // 否则继续比下一个位置；
  // 若还比不出来，比较两个数组的长度
  public static int compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    int len = Math.min(aLen, bLen);
    for (int i = 0; i < len; i++) {
      int aByte = a[i+aFromIndex] & 0xFF;
      int bByte = b[i+bFromIndex] & 0xFF;
      int diff = aByte - bByte;
      if (diff != 0) {
        return diff;
      }
    }

    // One is a prefix of the other, or, they are equal:
    return aLen - bLen;
  }

mismatch

   // 比较a数组与b数组，从哪个位置开始元素不同；如果全部相同返回-1
  public static int mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) {
    checkFromToIndex(aFromIndex, aToIndex, a.length);
    checkFromToIndex(bFromIndex, bToIndex, b.length);
    int aLen = aToIndex - aFromIndex;
    int bLen = bToIndex - bFromIndex;
    int len = Math.min(aLen, bLen);
    for (int i = 0; i < len; i++)
      if (a[i+aFromIndex] != b[i+bFromIndex])
        return i;
    return aLen == bLen ? -1 : len;
  }

类似的, 还有对于byte[]的mismatch方法。

相关文章

• 刨根究底字符编码之十四——UTF-16究竟是怎么编码的
• unicode字符网址
• Binary string comparison with UTF-16