使用RandomAccessFile读取单个UTF-8字符

Question

我已经设置了一个顺序扫描器，其中指向我的文件的RandomAccessFile可以通过以下方法读取单个字符：

public char nextChar() {
    try {
        seekPointer++;
        int i = source.read();
        return i > -1 ? (char) i : '\0'; // INFO: EOF character is -1.
    } catch (IOException e) {
        e.printStackTrace();
    }
    return '\0';
}

seekPointer只是我程序的引用，但是该方法将source.read()存储在int ，然后将其转换为char如果不是文件末尾）。 但是，我收到的这些字符都是ASCII格式，实际上它是如此糟糕，以至于我什至不能使用ç等符号。

有没有一种方法可以接收UTF-8格式的单个字符，或者至少允许一些标准化字符，而不仅仅是ASCII字符集？

我知道我可以使用readUTF()但是它将整行返回为String，这不是我想要的。

另外，我不能简单地使用另一个流读取器，因为我的程序需要一个seek(int)函数，允许我在文件中来回移动。

Answer 1

我不确定您要做什么，但是让我给您一些可能有用的信息。

UTF-8编码将字符表示为1、2、3或4个字节，具体取决于字符的Unicode值。

• 对于字符0x00-0x7F，UTF-8将字符编码为单个字节。 这是一个非常有用的属性，因为如果仅处理7位ASCII字符，则UTF-8和ASCII编码是相同的。
• 对于字符0x80-0x7FF，UTF-8使用2个字节：第一个字节是二进制110，后跟字符的5个高位，而第二个字节是二进制10，后跟字符的6个低位。
• 3字节和4字节编码类似于2字节编码，不同之处在于3字节编码的第一个字节以1110开头，而4字节编码的第一个字节以11110开头。
• 有关所有详细信息，请参见Wikipedia 。

现在，这看起来似乎很拜占庭，但是它的结果是：您可以读取UTF-8文件中的任何字节，并知道您是在查看独立字符，多字节字符的第一个字节还是另一个多字节字符的字节数。

如果读取的字节以二进制0开头，则说明您正在查看一个单字节字符。 如果以110、1110或11110开头，则您的多字节字符的第一个字节分别为2、3或4个字节。 如果以10开头，则为多字节字符的后续字节之一； 向后扫描以查找开始。

因此，如果您想让调用者查找文件中的任意位置并读取其中的UTF-8字符，则只需应用上述算法即可找到该字符的第一个字节（如果不是指定位置的那个字节） ），然后读取并解码该值。

有关从源字节解码UTF-8的方法，请参见Java Charset类。 也许有更简单的方法，但是Charset可以工作。

更新：此代码应处理1字节和2字节UTF-8情况。 尚未经过测试，YMMV。

for (;;) {
    int b = source.read();
    // Single byte character starting with binary 0.
    if ((b & 0x80) == 0)
        return (char) b;
    // 2-byte character starting with binary 110.
    if ((b & 0xE0) == 0xC0)
        return (char) ((b & 0x1F) << 6 | source.read() & 0x3F);
    // 3 and 4 byte encodings left as an exercise...
    // 2nd, 3rd, or 4th byte of a multibyte char starting with 10. 
    // Back up and loop.
    if ((b & 0xC0) == 0xF0) 
        source.seek(source.getFilePosition() - 2);
}

我不会打扰seekPointer。 RandomAccessFile知道它是什么。 只需在需要时调用getFilePosition。

Answer 2

从威利斯·布莱克本（Willis Blackburn）的答案出发，我可以简单地进行一些整数检查，以确保它们超过一定数量，以获取需要提前检查的字符数。

从下表判断：

first byte starts with 0                         1 byte char
first byte starts with 10    >= 128 && <= 191    ? byte(s) char
first byte starts with 11        >= 192          2 bytes char
first byte starts with 111       >= 224          3 bytes char
first byte starts with 1111      >= 240          4 bytes char

通过将其与中间列中的数字进行比较，我们可以检查从RandomAccessFile.read()读取的整数，这些数字实际上只是一个字节的整数表示形式。 这使我们可以完全跳过字节转换，从而节省时间。

下面的代码将从一个RandomAccessFile中读取一个字符，其字节长度为1-4：

int seekPointer = 0;
RandomAccessFile source; // initialise in your own way

public void seek(int shift) {
    seekPointer += shift;
    if (seekPointer < 0) seekPointer = 0;
    try {
        source.seek(seekPointer);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private int byteCheck(int chr) {
    if (chr == -1) return 1; // eof
    int i = 1; // theres always atleast one byte
    if (chr >= 192) i++; // 2 bytes
    if (chr >= 224) i++; // 3 bytes
    if (chr >= 240) i++; // 4 bytes
    if (chr >= 128 && chr <= 191) i = -1; // woops, we're halfway through a char!
    return i;
}

public char nextChar() {
    try {
        seekPointer++;
        int i = source.read();

        if (byteCheck(i) == -1) {
            boolean malformed = true;
            for (int k = 0; k < 4; k++) { // Iterate 3 times.
                // we only iterate 3 times because the maximum size of a utf-8 char is 4 bytes.
                // any further and we may possibly interrupt the other chars.
                seek(-1);
                i = source.read();
                if (byteCheck(i) != -1) {
                    malformed = false;
                    break;
                }
            }
            if (malformed) {
                seek(3);
                throw new UTFDataFormatException("Malformed UTF char at position: " + seekPointer);
            }
        }

        byte[] chrs = new byte[byteCheck(i)];
        chrs[0] = (byte) i;

        for (int j = 1; j < chrs.length; j++) {
            seekPointer++;
            chrs[j] = (byte) source.read();
        }

        return i > -1 ? new String(chrs, Charset.forName("UTF-8")).charAt(0) : '\0'; // EOF character is -1.
    } catch (IOException e) {
        e.printStackTrace();
    }
    return '\0';
}

Answer 3

从java.io.DataInputStream.readUTF(DataInput)的case语句，您可以派生出类似

public static char readUtf8Char(final DataInput dataInput) throws IOException {
    int char1, char2, char3;

    char1 = dataInput.readByte() & 0xff;
    switch (char1 >> 4) {
        case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
            /* 0xxxxxxx*/
            return (char)char1;
        case 12: case 13:
            /* 110x xxxx   10xx xxxx*/
            char2 = dataInput.readByte() & 0xff;
            if ((char2 & 0xC0) != 0x80) {
                throw new UTFDataFormatException("malformed input");
            }
            return (char)(((char1 & 0x1F) << 6) | (char2 & 0x3F));
        case 14:
            /* 1110 xxxx  10xx xxxx  10xx xxxx */
            char2 = dataInput.readByte() & 0xff;
            char3 = dataInput.readByte() & 0xff;
            if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80)) {
                throw new UTFDataFormatException("malformed input");
            }
            return (char)(((char1 & 0x0F) << 12) | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));
        default:
            /* 10xx xxxx,  1111 xxxx */
            throw new UTFDataFormatException("malformed input");
    }
}

请注意， RandomAccessFile实现了DataInput因此您可以将其传递给上述方法。 在为第一个字符调用它之前，您需要阅读一个无符号缩写，它表示UTF字符串长度。

请注意，如DataInput的Javadoc中所述，此处使用的编码是经过修改的UTF-8 。