Manera eficiente de calcular la longitud de bytes de un carácter, según la codificación

Question

¿Cuál es la forma más eficiente de calcular la longitud de bytes de un carácter, teniendo en cuenta la codificación de caracteres? La codificación solo se conocerá durante el tiempo de ejecución. En UTF-8, por ejemplo, los caracteres tienen una longitud de bytes variable, por lo que cada carácter debe determinarse individualmente. En lo que ahora se me ha ocurrido con esto:

char c = getCharSomehow(); 
String encoding = getEncodingSomehow(); 
// ... 
int length = new String(new char[] { c }).getBytes(encoding).length; 

Pero esto es torpe e ineficiente en un bucle desde un new String necesario crear cada vez. No puedo encontrar otras formas más eficientes en la API de Java. Hay un String#valueOf(char), pero según su fuente, básicamente es el mismo que el anterior. Me imagino que esto se puede hacer con operaciones a nivel de bits como desplazamiento de bits, pero eso es mi punto débil y estoy seguro de cómo tomar la codificación en cuenta aquí :)

_{Si duda de la necesidad de esto, compruebe this topic .}

---

Actualización: la respuesta de @Bkkbrad es técnicamente la más eficiente:

char c = getCharSomehow(); 
String encoding = getEncodingSomehow(); 
CharsetEncoder encoder = Charset.forName(encoding).newEncoder(); 
// ... 
int length = encoder.encode(CharBuffer.wrap(new char[] { c })).limit(); 

Sin embargo, como @Stephen C señalado, hay más problemas con esto. Puede haber, por ejemplo, caracteres combinados/sustitutos que también deben tenerse en cuenta. Pero ese es otro problema que debe resolverse en el paso antes de en este paso.

Answer 1

Utilice CharsetEncoder y reutilice CharBuffer como entrada y ByteBuffer como salida.

En mi sistema, el siguiente código tarda 25 segundos para codificar 100.000 caracteres individuales:

Charset utf8 = Charset.forName("UTF-8"); 
char[] array = new char[1]; 
for (int reps = 0; reps < 10000; reps++) { 
    for (array[0] = 0; array[0] < 10000; array[0]++) { 
     int len = new String(array).getBytes(utf8).length; 
    } 
} 

Sin embargo, el código siguiente hace lo mismo en menos de 4 segundos:

Charset utf8 = Charset.forName("UTF-8"); 
CharsetEncoder encoder = utf8.newEncoder(); 
char[] array = new char[1]; 
CharBuffer input = CharBuffer.wrap(array); 
ByteBuffer output = ByteBuffer.allocate(10); 
for (int reps = 0; reps < 10000; reps++) { 
    for (array[0] = 0; array[0] < 10000; array[0]++) { 
     output.clear(); 
     input.clear(); 
     encoder.encode(input, output, false); 
     int len = output.position(); 
    } 
} 

Editar : ¿Por qué los enemigos tienen que odiar?

He aquí una solución que se lee de un CharBuffer y realiza un seguimiento de surrogate pairs:

Charset utf8 = Charset.forName("UTF-8"); 
CharsetEncoder encoder = utf8.newEncoder(); 
CharBuffer input = //allocate in some way, or pass as parameter 
ByteBuffer output = ByteBuffer.allocate(10); 

int limit = input.limit(); 
while(input.position() < limit) { 
    output.clear(); 
    input.mark(); 
    input.limit(Math.max(input.position() + 2, input.capacity())); 
    if (Character.isHighSurrogate(input.get()) && !Character.isLowSurrogate(input.get())) { 
     //Malformed surrogate pair; do something! 
    } 
    input.limit(input.position()); 
    input.reset(); 
    encoder.encode(input, output, false); 
    int encodedLen = output.position(); 
} 

Answer 2

Es posible que un esquema de codificación pueda codificar un carácter dado como un número variable de bytes, dependiendo de lo que ocurra antes y después de él en la secuencia de caracteres. La longitud de bytes que obtienes al codificar un solo carácter. Cadena no es, por lo tanto, la respuesta completa.

(Por ejemplo, en teoría, podría recibir un baudot/teletipo caracteres codificados como 4 caracteres cada 3 bytes, o en teoría podría tratar un UTF-16 + un compresor de flujo como un esquema de codificación. Sí, es todo un poco no plausible, pero ...)

Answer 3

Si puede garantizar que la entrada está bien formada UTF-8, entonces no hay razón para encontrar puntos de código en absoluto. Una de las ventajas de UTF-8 es que puede detectar el inicio de un punto de código desde cualquier posición en la cadena. Simplemente busque hacia atrás hasta encontrar un byte tal que (b & 0xc0)! = 0x80, y haya encontrado otro carácter. Como un punto de código codificado en UTF-8 es siempre de 6 bytes o menos, puede copiar los bytes intermedios en un búfer de longitud fija.

Editar: Olvidé mencionar, incluso si no sigue esta estrategia, no es suficiente usar un "carácter" Java para almacenar puntos de código arbitrario ya que los valores de punto de código pueden exceder 0xffff. Necesita almacenar puntos de código en un "int".

Answer 4

Probar Charset.forName("UTF-8").encode("string").limit(); Puede ser un poco más eficiente, tal vez no.