¿Cómo trunco ​​una cadena java para caber en un número dado de bytes, una vez que UTF-8 está codificado?

Question

¿Cómo trunco ​​un java String para que sepa que cabe en un número dado de almacenamiento de bytes una vez que está codificado en UTF-8?

Answer 1

Aquí es un simple bucle que cuenta cuán grande es la representación UTF-8 va a ser, y trunca cuando se excede:

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; 
} 

Este hace manejar surrogate pairs que aparecen en la cadena de entrada. El codificador UTF-8 de Java (correctamente) genera parejas sustitutas como una secuencia de 4 bytes en lugar de dos secuencias de 3 bytes, por lo que truncateWhenUTF8() devolverá la cadena truncada más larga que pueda. Si ignora los pares suplentes en la implementación, las cadenas truncadas pueden acortarse de lo necesario.

no he hecho un montón de pruebas en ese código, pero aquí hay algunas pruebas preliminares:

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); 

} 

Actualizado ejemplo de código modificado, que ahora se encarga de los pares suplentes.

Answer 2

La codificación UTF-8 tiene un rasgo perfecto que le permite ver en qué lugar de un byte se encuentra.

verifique la transmisión con el límite de caracteres que desee.

• Si su bit alto es 0, es un carácter de byte único, simplemente reemplázalo por 0 y todo irá bien.
• Si su bit alto es 1 y también lo es el siguiente bit, entonces estás al inicio de un char de varios bytes, así que simplemente establece ese byte en 0 y estás bien.
• Si el bit alto es 1 pero el siguiente bit es 0, entonces estás en el medio de un personaje, retrocedes por el buffer hasta que alcances un byte que tiene 2 o más 1s en los bits altos, y reemplazas ese byte con 0.

Ejemplo: Si su flujo es: 31 33 31 C1 A3 32 33 00, puede hacer su cadena 1, 2, 3, 5, 6 o 7 bytes, pero no 4 , ya que eso pondría el 0 después de C1, que es el inicio de un char de múltiples bytes.

Answer 3

Debe usar CharsetEncoder, el simple getBytes() + copie todos los que pueda para cortar los charts UTF-8 a la mitad.

Algo como esto:

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 4

Puede calcular el número de bytes sin realizar ninguna conversión.

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 
    } 

Usted tendría que detectar pares suplentes (D800-DBFF y U + DC00-U + DFFF) y contar 4 bytes para cada par sustituto válido. Si obtiene el primer valor en el primer rango y el segundo en el segundo, todo está bien, omítelos y agregue 4. Pero si no es así, entonces es un par sustituto no válido. No estoy seguro de cómo Java trata con eso, pero su algoritmo tendrá que hacer un conteo correcto en ese caso (poco probable).

Answer 5

Esto es lo que se me ocurrió, utiliza API Java estándar por lo que debe ser seguro y compatible con todas las rarezas Unicode y pares de sustitución, etc.La solución se toma desde http://www.jroller.com/holy/entry/truncating_utf_string_to_the con comprobaciones agregadas para null y para evitar la decodificación cuando la cadena tiene menos bytes que 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()); 
}