bytes de uma string em java?

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

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

Dito isso, você pode transformar a string em uma matriz de bytes e, em seguida, examinar 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" 

Então, você vê, até mesmo uma simples string “ASCII” pode ter diferentes números de bytes em sua representação, dependendo de qual codificação é usada. Use qualquer conjunto de caracteres que você esteja interessado no seu caso, como o argumento para getBytes() . E não caia na armadilha de assumir que o UTF-8 representa todos os caracteres como um único byte, como 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 de 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 de caracteres explícito ao codificar / decodificação é necessária.)

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 em uma VM de 64 bits com OOPs compactados (-XX: + UseCompressedOops), as referências são de 4 bytes. Então o total seria:

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

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

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

 string.length() * 2 

As strings Java são fisicamente armazenadas na UTF-16BE , 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 lhe dirá o tamanho da matriz de char internos, em bytes .

Nota: "UTF-16" fornecerá um resultado diferente de "UTF-16BE" pois a codificação anterior inserirá uma BOM , 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 instância String aloca uma certa quantidade de bytes na memory. Talvez você esteja olhando para algo como sizeof("Hello World") que retornaria o número de bytes alocados pela própria estrutura de dados?

Em Java, geralmente não há necessidade de um sizeof function, porque nunca alocamos memory para armazenar uma estrutura de dados. Podemos dar uma olhada no arquivo String.java para uma estimativa aproximada, e vemos alguns ‘int’, algumas referências e um char[] . A especificação da linguagem Java define que um char varia de 0 a 65535, portanto, dois bytes são suficientes para manter um único caractere na memory. Mas uma JVM não precisa armazenar um caracter em 2 bytes, só tem que garantir, que a implementação de char pode conter valores do range de definições.

Portanto, sizeof realmente não faz sentido em Java. Mas, assumindo que temos um String grande e um char aloca dois bytes, o footprint de memory de um object String é pelo menos 2 * str.length() em bytes.

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

Tente isto:

 Bytes.toBytes(x).length 

Assumindo que você declarou e inicializou x antes