Как урезать java String
, чтобы я знал, что он будет вписываться в заданное количество байт-хранилища после кодирования UTF-8?
Как обрезать строку java, чтобы она соответствовала заданному количеству байтов после кодирования UTF-8?
Ответ 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);
}
Обновлен Модифицированный пример кода, теперь он обрабатывает суррогатные пары.
Ответ 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();
}
Ответ 3
Кодирование UTF-8 имеет опрятный признак, который позволяет вам видеть, где вы находитесь в байтовом наборе.
проверьте поток с нужным символом.
- Если его старший бит равен 0, это однобайтовый char, просто замените его на 0, и вы в порядке.
- Если его старший бит равен 1, а значит, следующий бит, то вы начинаете многобайтный char, поэтому просто установите этот байт в 0 и вы добры.
- Если старший бит равен 1, а следующий бит равен 0, то вы находитесь в середине символа, перемещайтесь по буфере до тех пор, пока не нажмете байта с 2 или более 1 сек в высоких битах и замените этот байт с 0.
Пример: если ваш поток: 31 33 31 C1 A3 32 33 00, вы можете сделать свою строку длиной 1, 2, 3, 5, 6 или 7 байтов, но не 4, так как это положило бы 0 после C1, который является началом многобайтового char.
Ответ 4
Вот что я придумал, он использует стандартные Java API, поэтому должен быть безопасным и совместимым со всеми странностями юникода и суррогатными парами и т.д. Решение взято из http://www.jroller.com/holy/entry/truncating_utf_string_to_the с проверками, добавленными для null, и для избежания декодирования, когда строка меньше байтов, чем 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());
}
Ответ 5
Вы можете рассчитать количество байтов без какого-либо преобразования.
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 справляется с этим, но ваш алгоритм должен будет делать правильный подсчет в этом (маловероятном) случае.