Bytes de una cadena en Java

En Java, si tengo una cadena x, ¿cómo puedo calcular el número de bytes en esa cadena?

Una cadena es una lista de caracteres (es decir, puntos de código). La cantidad de bytes que se toman para representar la cadena depende completamente de la codificación que use para convertirla en bytes .

Dicho esto, puede convertir la cadena en una matriz de bytes y luego ver su tamaño de la siguiente manera:

// The input string for this test
final String string = "Hello World";

// Check length, in characters
System.out.println(string.length()); // prints "11"

// Check encoded sizes
final byte[] utf8Bytes = string.getBytes("UTF-8");
System.out.println(utf8Bytes.length); // prints "11"

final byte[] utf16Bytes= string.getBytes("UTF-16");
System.out.println(utf16Bytes.length); // prints "24"

final byte[] utf32Bytes = string.getBytes("UTF-32");
System.out.println(utf32Bytes.length); // prints "44"

final byte[] isoBytes = string.getBytes("ISO-8859-1");
System.out.println(isoBytes.length); // prints "11"

final byte[] winBytes = string.getBytes("CP1252");
System.out.println(winBytes.length); // prints "11"

Como puede ver, incluso una cadena simple "ASCII" puede tener un número diferente de bytes en su representación, dependiendo de la codificación utilizada. Utilice el conjunto de caracteres que le interese para su caso, como argumento para getBytes(). Y no caigas en la trampa de asumir que UTF-8 representa a cada personaje como un solo byte, ya que eso tampoco es cierto:

final String interesting = "\uF93D\uF936\uF949\uF942"; // Chinese ideograms

// Check length, in characters
System.out.println(interesting.length()); // prints "4"

// Check encoded sizes
final byte[] utf8Bytes = interesting.getBytes("UTF-8");
System.out.println(utf8Bytes.length); // prints "12"

final byte[] utf16Bytes= interesting.getBytes("UTF-16");
System.out.println(utf16Bytes.length); // prints "10"

final byte[] utf32Bytes = interesting.getBytes("UTF-32");
System.out.println(utf32Bytes.length); // prints "16"

final byte[] isoBytes = interesting.getBytes("ISO-8859-1");
System.out.println(isoBytes.length); // prints "4" (probably encoded "????")

final byte[] winBytes = interesting.getBytes("CP1252");
System.out.println(winBytes.length); // prints "4" (probably encoded "????")

(Tenga en cuenta que si no proporciona un argumento de juego de caracteres, se usa el juego de caracteres predeterminado de la plataforma . Esto puede ser útil en algunos contextos, pero en general debe evitar depender de los valores predeterminados y siempre usar un juego de caracteres explícito al codificar / Se requiere decodificación.)

Si está ejecutando con referencias de 64 bits:

sizeof(string) = 
8 + // object header used by the VM
8 + // 64-bit reference to char array (value)
8 + string.length() * 2 + // character array itself (object header + 16-bit chars)
4 + // offset integer
4 + // count integer
4 + // cached hash code

En otras palabras:

sizeof(string) = 36 + string.length() * 2

En una máquina virtual de 32 bits o una máquina virtual de 64 bits con OOP comprimidos (-XX: + UseCompressedOops), las referencias son de 4 bytes. Entonces el total sería:

sizeof(string) = 32 + string.length() * 2

Esto no tiene en cuenta las referencias al objeto de cadena.

La respuesta pedante (aunque no necesariamente la más útil, dependiendo de lo que quieras hacer con el resultado) es:

string.length() * 2

Las cadenas de Java se almacenan físicamente en la UTF-16BEcodificación, que utiliza 2 bytes por unidad de código, y String.length()mide la longitud en unidades de código UTF-16, por lo que esto es equivalente a:

final byte[] utf16Bytes= string.getBytes("UTF-16BE");
System.out.println(utf16Bytes.length);

Y esto le dirá el tamaño de la charmatriz interna , en bytes .

Nota: "UTF-16"dará un resultado diferente "UTF-16BE"ya que la codificación anterior insertará una lista de materiales , agregando 2 bytes a la longitud de la matriz.

De acuerdo con Cómo convertir cadenas hacia y desde matrices de bytes UTF8 en Java :

String s = "some text here";
byte[] b = s.getBytes("UTF-8");
System.out.println(b.length);

Una Stringinstancia asigna una cierta cantidad de bytes en la memoria. ¿Quizás esté viendo algo como sizeof("Hello World")lo que devolvería el número de bytes asignados por la estructura de datos en sí?

En Java, generalmente no hay necesidad de una sizeoffunción, porque nunca asignamos memoria para almacenar una estructura de datos. Podemos echar un vistazo al String.javaarchivo para una estimación aproximada, y vemos algunos 'int', algunas referencias y a char[]. La especificación del lenguaje Java define que un charrango va de 0 a 65535, por lo que dos bytes son suficientes para mantener un único carácter en la memoria. Pero una JVM no tiene que almacenar un carácter en 2 bytes, solo tiene que garantizar que la implementación de charpuede contener valores del rango definido.

Entonces sizeofrealmente no tiene ningún sentido en Java. Pero, suponiendo que tenemos una cadena grande y una charasigna dos bytes, la huella de memoria de un Stringobjeto es al menos 2 * str.length()en bytes.

Hay un método llamado getBytes () . Úsalo con sabiduría .

Prueba esto :

Bytes.toBytes(x).length

Asumiendo que declaraste e inicializaste x antes

Para evitar intentar atrapar, use:

String s = "some text here";
byte[] b = s.getBytes(StandardCharsets.UTF_8);
System.out.println(b.length);