Byte di una stringa in Java

In Java, se ho una stringa x, come posso calcolare il numero di byte in quella stringa?

Una stringa è un elenco di caratteri (ovvero punti di codice). Il numero di byte utilizzati per rappresentare la stringa dipende interamente dalla codifica utilizzata per trasformarla in byte .

Detto questo, puoi trasformare la stringa in una matrice di byte e quindi guardare le sue dimensioni come segue:

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

Come vedi, anche una semplice stringa "ASCII" può avere un numero diverso di byte nella sua rappresentazione, a seconda della codifica utilizzata. Usa qualsiasi set di caratteri che ti interessa per il tuo caso, come argomento a getBytes(). E non cadere nella trappola di supporre che UTF-8 rappresenti ogni carattere come un singolo byte, dato che non è neanche vero:

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

(Tieni presente che se non fornisci un argomento del set di caratteri, viene utilizzato il set di caratteri predefinito della piattaforma . Ciò potrebbe essere utile in alcuni contesti, ma in generale dovresti evitare a seconda delle impostazioni predefinite e utilizzare sempre un set di caratteri esplicito durante la codifica / è richiesta la decodifica.)

Se si esegue con riferimenti a 64 bit:

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

In altre parole:

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

Su una macchina virtuale a 32 bit o una macchina virtuale a 64 bit con OOP compressi (-XX: + UseCompressedOops), i riferimenti sono 4 byte. Quindi il totale sarebbe:

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

Ciò non tiene conto dei riferimenti all'oggetto stringa.

La risposta pedante (anche se non necessariamente la più utile, a seconda di cosa vuoi fare con il risultato) è:

string.length() * 2

Le stringhe Java sono archiviate fisicamente nella UTF-16BEcodifica, che utilizza 2 byte per unità di codice e String.length()misura la lunghezza in unità di codice UTF-16, quindi questo equivale a:

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

E questo ti dirà la dimensione chardell'array interno , in byte .

Nota: "UTF-16"darà un risultato diverso da "UTF-16BE"come la precedente codifica inserirà una DBA , aggiungendo 2 byte alla lunghezza dell'array.

Secondo Come convertire le stringhe da e verso array di byte UTF8 in Java :

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

Un Stringesempio alloca una certa quantità di byte in memoria. Forse stai osservando qualcosa del genere sizeof("Hello World")che restituirebbe il numero di byte allocati dalla stessa struttura dati?

In Java, di solito non è necessaria una sizeoffunzione, perché non allociamo mai memoria per memorizzare una struttura di dati. Possiamo dare un'occhiata al String.javafile per una stima approssimativa, e vediamo alcuni 'int', alcuni riferimenti e a char[]. La specifica del linguaggio Java definisce che un charintervallo va da 0 a 65535, quindi due byte sono sufficienti per mantenere un singolo carattere in memoria. Ma una JVM non deve archiviare un carattere in 2 byte, deve solo garantire che l'implementazione di charpuò contenere valori dell'intervallo definito.

Quindi sizeofdavvero non ha alcun senso in Java. Ma supponendo che abbiamo una stringa di grandi dimensioni e una charalloca due byte, l'impronta di memoria di un Stringoggetto è almeno 2 * str.length()in byte.

C'è un metodo chiamato getBytes () . Usalo saggiamente.

Prova questo :

Bytes.toBytes(x).length

Supponendo di aver dichiarato e inizializzato x prima

Per evitare di provare, utilizzare:

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