Как мне обрезать строку Java, чтобы она соответствовала заданному числу байтов после кодирования UTF-8?

Question

Как мне усечь java String, чтобы я знал, что она поместится в определенном количестве байтов, как только она будет закодирована в UTF-8?

Answer 1

Вот простой цикл, который подсчитывает, насколько большим будет представление UTF-8, и усекает его при превышении:

public static String truncateWhenUTF8(String s, int maxBytes) {
    int b = 0;
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);

        // ranges from http://en.wikipedia.org/wiki/UTF-8
        int skip = 0;
        int more;
        if (c <= 0x007f) {
            more = 1;
        }
        else if (c <= 0x07FF) {
            more = 2;
        } else if (c <= 0xd7ff) {
            more = 3;
        } else if (c <= 0xDFFF) {
            // surrogate area, consume next char as well
            more = 4;
            skip = 1;
        } else {
            more = 3;
        }

        if (b + more > maxBytes) {
            return s.substring(0, i);
        }
        b += more;
        i += skip;
    }
    return s;
}

Это делает обработку суррогатных пар , которые появляются во входной строке. Кодер Java UTF-8 (правильно) выводит суррогатные пары в виде одной 4-байтовой последовательности вместо двух 3-байтовых последовательностей, поэтому truncateWhenUTF8() вернет самую длинную усеченную строку, какую только может. Если вы игнорируете суррогатные пары в реализации, то усеченные строки могут быть закорочены, чем они должны быть.

Я не много тестировал этот код, но вот несколько предварительных тестов:

private static void test(String s, int maxBytes, int expectedBytes) {
    String result = truncateWhenUTF8(s, maxBytes);
    byte[] utf8 = result.getBytes(Charset.forName("UTF-8"));
    if (utf8.length > maxBytes) {
        System.out.println("BAD: our truncation of " + s + " was too big");
    }
    if (utf8.length != expectedBytes) {
        System.out.println("BAD: expected " + expectedBytes + " got " + utf8.length);
    }
    System.out.println(s + " truncated to " + result);
}

public static void main(String[] args) {
    test("abcd", 0, 0);
    test("abcd", 1, 1);
    test("abcd", 2, 2);
    test("abcd", 3, 3);
    test("abcd", 4, 4);
    test("abcd", 5, 4);

    test("a\u0080b", 0, 0);
    test("a\u0080b", 1, 1);
    test("a\u0080b", 2, 1);
    test("a\u0080b", 3, 3);
    test("a\u0080b", 4, 4);
    test("a\u0080b", 5, 4);

    test("a\u0800b", 0, 0);
    test("a\u0800b", 1, 1);
    test("a\u0800b", 2, 1);
    test("a\u0800b", 3, 1);
    test("a\u0800b", 4, 4);
    test("a\u0800b", 5, 5);
    test("a\u0800b", 6, 5);

    // surrogate pairs
    test("\uD834\uDD1E", 0, 0);
    test("\uD834\uDD1E", 1, 0);
    test("\uD834\uDD1E", 2, 0);
    test("\uD834\uDD1E", 3, 0);
    test("\uD834\uDD1E", 4, 4);
    test("\uD834\uDD1E", 5, 4);

}

Обновлено Пример модифицированного кода, теперь он обрабатывает суррогатные пары.

Answer 2

Вы должны использовать CharsetEncoder , простую getBytes() + копию, сколько вы можете разрезать UTF-8 символов пополам.

Примерно так:

public static int truncateUtf8(String input, byte[] output) {

    ByteBuffer outBuf = ByteBuffer.wrap(output);
    CharBuffer inBuf = CharBuffer.wrap(input.toCharArray());

    Charset utf8 = Charset.forName("UTF-8");
    utf8.newEncoder().encode(inBuf, outBuf, true);
    System.out.println("encoded " + inBuf.position() + " chars of " + input.length() + ", result: " + outBuf.position() + " bytes");
    return outBuf.position();
}

Answer 3

Вот то, что я придумал, он использует стандартные API-интерфейсы Java, поэтому должен быть безопасным и совместимым со всеми странными парами юникода и суррогатными парами и т. Д. Решение взято из http://www.jroller.com/holy/entry/truncating_utf_string_to_the с проверками, добавленными для нулевого значения и для избежания декодирование, когда строка меньше байтов, чем maxBytes .

/**
 * Truncates a string to the number of characters that fit in X bytes avoiding multi byte characters being cut in
 * half at the cut off point. Also handles surrogate pairs where 2 characters in the string is actually one literal
 * character.
 *
 * Based on: http://www.jroller.com/holy/entry/truncating_utf_string_to_the
 */
public static String truncateToFitUtf8ByteLength(String s, int maxBytes) {
    if (s == null) {
        return null;
    }
    Charset charset = Charset.forName("UTF-8");
    CharsetDecoder decoder = charset.newDecoder();
    byte[] sba = s.getBytes(charset);
    if (sba.length <= maxBytes) {
        return s;
    }
    // Ensure truncation by having byte buffer = maxBytes
    ByteBuffer bb = ByteBuffer.wrap(sba, 0, maxBytes);
    CharBuffer cb = CharBuffer.allocate(maxBytes);
    // Ignore an incomplete character
    decoder.onMalformedInput(CodingErrorAction.IGNORE)
    decoder.decode(bb, cb, true);
    decoder.flush(cb);
    return new String(cb.array(), 0, cb.position());
}

Answer 4

Кодировка UTF-8 имеет удобную черту, которая позволяет вам видеть, где вы находитесь в наборе байтов.

проверьте поток на желаемое количество символов.

• Если его старший бит равен 0, это однобайтовый символ, просто замените его на 0, и все в порядке.
• Если его старший бит равен 1 и, следовательно, является следующим битом, то вы находитесь в начале многобайтового символа, поэтому просто установите этот байт в 0, и все в порядке.
• Если старший бит равен 1, но следующий бит равен 0, то вы находитесь в середине символа, перемещаетесь назад по буферу, пока не попадете в байт, имеющий 2 или более единиц в старших битах, и замените этот байт с 0.

Пример: если ваш поток: 31 33 31 C1 A3 32 33 00, вы можете сделать вашу строку длиной 1, 2, 3, 5, 6 или 7 байтов, но не 4, так как это поставит 0 после C1, который является началом многобайтового символа.

Answer 5

вы можете использовать -new String (data.getBytes ("UTF-8"), 0, maxLen, "UTF-8");

Answer 6

Вы можете вычислить количество байтов без каких-либо преобразований.

foreach character in the Java string
  if 0 <= character <= 0x7f
     count += 1
  else if 0x80 <= character <= 0x7ff
     count += 2
  else if 0x800 <= character <= 0xd7ff // excluding the surrogate area
     count += 3
  else if 0xdc00 <= character <= 0xffff
     count += 3
  else { // surrogate, a bit more complicated
     count += 4
     skip one extra character in the input stream
  }

Вы должны обнаружить суррогатные пары (D800-DBFF и U + DC00-U + DFFF) и считать 4 байта для каждой действительной суррогатной пары. Если вы получите первое значение в первом диапазоне и второе во втором диапазоне, все в порядке, пропустите их и добавьте 4. Но если нет, то это недопустимая суррогатная пара. Я не уверен, как Java справляется с этим, но ваш алгоритм должен будет делать правильный подсчет в этом (маловероятном) случае.