Java ArrayUtil.byteArrayToChars方法代码示例

import org.hsqldb.lib.ArrayUtil; //导入方法依赖的package包/类
public Result getChars(long lobID, long offset, int length) {

        Result result;

        writeLock.lock();

        try {
            if (compressLobs || cryptLobs) {
                result = getBytesCompressed(lobID, offset * 2, length * 2,
                                            true);
            } else {
                result = getBytesNormal(lobID, offset * 2, length * 2);
            }
        } finally {
            writeLock.unlock();
        }

        if (result.isError()) {
            return result;
        }

        byte[] bytes = ((ResultLob) result).getByteArray();
        char[] chars = ArrayUtil.byteArrayToChars(bytes);

        return ResultLob.newLobGetCharsResponse(lobID, offset, chars);
    }
 

import org.hsqldb.lib.ArrayUtil; //导入方法依赖的package包/类
private int compareTextCompressed(Collation collation, long aID,
                                  long bID) {

    long[][] aParts = getParts(aID, 0, Long.MAX_VALUE);
    long[][] bParts = getParts(bID, 0, Long.MAX_VALUE);

    for (int i = 0; i < aParts.length && i < bParts.length; i++) {
        int aPartLength = (int) aParts[i][ALLOC_PART.PART_LENGTH];

        getPartBytesCompressedInBuffer(aID, aParts[i], true);

        String aString = new String(ArrayUtil.byteArrayToChars(dataBuffer,
            aPartLength));
        int bPartLength = (int) bParts[i][ALLOC_PART.PART_LENGTH];

        getPartBytesCompressedInBuffer(bID, bParts[i], true);

        String bString = new String(ArrayUtil.byteArrayToChars(dataBuffer,
            bPartLength));
        int diff = collation.compare(aString, bString);

        if (diff != 0) {
            return diff;
        }
    }

    if (aParts.length == bParts.length) {
        return 0;
    }

    return aParts.length > bParts.length ? 1
                                         : -1;
}
 

import org.hsqldb.lib.ArrayUtil; //导入方法依赖的package包/类
/** @todo - implement as compareText() */
public int compare(Collation collation, ClobData a, String b) {

    writeLock.lock();

    try {
        Object[] data    = getLobHeader(a.getId());
        long     aLength = ((Long) data[LOB_IDS.LOB_LENGTH]).longValue();
        int[][] aAddresses = getBlockAddresses(a.getId(), 0,
                                               Integer.MAX_VALUE);
        int aIndex  = 0;
        int bOffset = 0;
        int aOffset = 0;

        if (aLength == 0) {
            return b.length() == 0 ? 0
                                   : -1;
        }

        if (b.length() == 0) {
            return 1;
        }

        while (true) {
            int aBlockOffset = aAddresses[aIndex][LOBS.BLOCK_ADDR]
                               + aOffset;
            byte[] aBytes = getLobStore().getBlockBytes(aBlockOffset, 1);
            long aLimit =
                aLength
                - ((long) aAddresses[aIndex][LOBS.BLOCK_OFFSET] + aOffset)
                  * lobBlockSize / 2;

            if (aLimit > lobBlockSize / 2) {
                aLimit = lobBlockSize / 2;
            }

            String aString = new String(ArrayUtil.byteArrayToChars(aBytes),
                                        0, (int) aLimit);
            int bLimit = b.length() - bOffset;

            if (bLimit > lobBlockSize / 2) {
                bLimit = lobBlockSize / 2;
            }

            String bString = b.substring(bOffset, bOffset + bLimit);
            int    diff    = collation.compare(aString, bString);

            if (diff != 0) {
                return diff;
            }

            aOffset++;

            bOffset += lobBlockSize / 2;

            if (aOffset == aAddresses[aIndex][LOBS.BLOCK_COUNT]) {
                aOffset = 0;

                aIndex++;
            }

            if (aIndex == aAddresses.length) {
                break;
            }

            if (bOffset >= b.length()) {
                break;
            }
        }

        if (aLength == b.length()) {
            return 0;
        }

        return aLength > b.length() ? 1
                                    : -1;
    } finally {
        writeLock.unlock();
    }
}