Bytes de uma string em Java

Em Java, se eu tiver uma String x, como posso calcular o número de bytes nessa string?

Uma string é uma lista de caracteres (ou seja, pontos de código). O número de bytes utilizados para representar a sequência depende inteiramente da codificação usada para transformá-la em bytes .

Dito isso, você pode transformar a string em uma matriz de bytes e, em seguida, analisar seu tamanho da seguinte maneira:

// 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"

Veja bem, mesmo uma simples string "ASCII" pode ter um número diferente de bytes em sua representação, dependendo da codificação usada. Use o conjunto de caracteres de seu interesse para o seu caso, como argumento getBytes(). E não caia na armadilha de supor que UTF-8 represente todos os caracteres como um único byte, pois isso também não é verdade:

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 "????")

(Observe que, se você não fornecer um argumento para o conjunto de caracteres, o conjunto de caracteres padrão da plataforma será usado. Isso pode ser útil em alguns contextos, mas, em geral, você deve evitar os padrões e sempre usar um conjunto explícito de caracteres ao codificar / decodificação.)

Se você estiver executando com referências 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

Em outras palavras:

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

Em uma VM de 32 bits ou de 64 bits com OOPs compactados (-XX: + UseCompressedOops), as referências são de 4 bytes. Portanto, o total seria:

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

Isso não leva em consideração as referências ao objeto string.

A resposta pedante (embora não necessariamente a mais útil, dependendo do que você quer fazer com o resultado) é:

string.length() * 2

As seqüências Java são fisicamente armazenadas na UTF-16BEcodificação, que usa 2 bytes por unidade de código e String.length()mede o comprimento em unidades de código UTF-16, portanto, isso é equivalente a:

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

E isso informará o tamanho da charmatriz interna , em bytes .

Nota: "UTF-16"fornecerá um resultado diferente, "UTF-16BE"pois a codificação anterior inserirá uma lista técnica , adicionando 2 bytes ao comprimento da matriz.

De acordo com Como converter seqüências de caracteres para e de matrizes de bytes UTF8 em Java :

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

Uma Stringinstância aloca uma certa quantidade de bytes na memória. Talvez você esteja olhando para algo comosizeof("Hello World") que retornaria o número de bytes alocados pela própria estrutura de dados?

Em Java, geralmente não há necessidade de uma sizeoffunção, porque nunca alocamos memória para armazenar uma estrutura de dados. Podemos dar uma olhada no String.javaarquivo para obter uma estimativa aproximada, e vemos alguns 'int', algumas referências e a char[]. A especificação da linguagem Java define, que charvaria de 0 a 65535, portanto, dois bytes são suficientes para manter um único caractere na memória. Mas uma JVM não precisa armazenar um caractere em 2 bytes, apenas tem que garantir que a implementação dechar possa conter valores do intervalo define.

Então, sizeofrealmente não faz sentido em Java. Mas, supondo que tenhamos uma String grande e uma charaloque dois bytes, o espaço ocupado pela memória de um Stringobjeto será pelo menos 2 * str.length()em bytes.

Existe um método chamado getBytes () . Use com sabedoria.

Tente o seguinte:

Bytes.toBytes(x).length

Supondo que você declarou e inicializou x antes

Para evitar tentar capturar, use:

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