Bytes einer Zeichenfolge in Java

xWie kann ich in Java, wenn ich eine Zeichenfolge habe, die Anzahl der Bytes in dieser Zeichenfolge berechnen?

Eine Zeichenfolge ist eine Liste von Zeichen (dh Codepunkten). Die Anzahl der Bytes, die zur Darstellung der Zeichenfolge benötigt werden hängt vollständig davon ab, welche Codierung Sie verwenden, um sie in Bytes umzuwandeln .

Sie können den String jedoch in ein Byte-Array umwandeln und dann seine Größe wie folgt betrachten:

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

Sie sehen also, dass selbst eine einfache "ASCII" -String in ihrer Darstellung eine unterschiedliche Anzahl von Bytes haben kann, je nachdem, welche Codierung verwendet wird. Verwenden Sie den gewünschten Zeichensatz für Ihren Fall als Argument dafür getBytes(). Und geraten Sie nicht in die Falle, anzunehmen, dass UTF-8 jedes Zeichen als einzelnes Byte darstellt, da dies auch nicht zutrifft:

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

(Beachten Sie, dass der Standardzeichensatz der Plattform verwendet wird, wenn Sie kein Zeichensatzargument angeben . Dies kann in einigen Kontexten nützlich sein. Im Allgemeinen sollten Sie jedoch die Abhängigkeit von den Standardeinstellungen vermeiden und beim Codieren / immer einen expliziten Zeichensatz verwenden Dekodierung ist erforderlich.)

Wenn Sie mit 64-Bit-Referenzen arbeiten:

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

Mit anderen Worten:

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

Auf einer 32-Bit-VM oder einer 64-Bit-VM mit komprimierten OOPs (-XX: + UseCompressedOops) sind die Referenzen 4 Byte. Die Summe wäre also:

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

Dies berücksichtigt nicht die Verweise auf das Zeichenfolgenobjekt.

Die pedantische Antwort (obwohl nicht unbedingt die nützlichste, je nachdem, was Sie mit dem Ergebnis machen möchten) lautet:

string.length() * 2

Java-Zeichenfolgen werden physisch in der UTF-16BECodierung gespeichert , die 2 Bytes pro Codeeinheit verwendet und String.length()die Länge in UTF-16-Codeeinheiten misst. Dies entspricht also:

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

Und dies zeigt Ihnen die Größe des internen charArrays in Bytes .

Hinweis: "UTF-16"Gibt ein anderes Ergebnis "UTF-16BE"als die vorherige Codierung, fügt eine Stückliste ein und addiert 2 Bytes zur Länge des Arrays.

Laut Wie konvertiert Strings zu und von UTF8 Byte - Arrays in Java :

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

Eine StringInstanz weist eine bestimmte Anzahl von Bytes im Speicher zu. Vielleicht schaust du dir so etwas ansizeof("Hello World") das die Anzahl der von der Datenstruktur selbst zugewiesenen Bytes zurückgibt?

In Java ist normalerweise keine sizeofFunktion erforderlich , da wir niemals Speicher zum Speichern einer Datenstruktur zuweisen. Wir können uns die String.javaDatei ansehen, um eine grobe Schätzung zu erhalten, und wir sehen einige 'int', einige Referenzen und a char[]. Das Java-Sprachspezifikation definiert, dass a charzwischen 0 und 65535 liegt, sodass zwei Bytes ausreichen, um ein einzelnes Zeichen im Speicher zu halten. Aber eine JVM muss nicht ein Zeichen in 2 Bytes speichern, sondern nur garantieren, dass die Implementierung vonchar Werte des definierten Bereichs enthalten kann.

Also sizeofmacht das in Java wirklich keinen Sinn. Unter der Annahme, dass wir einen großen String haben und einer charzwei Bytes zuweist, Stringbeträgt der Speicherbedarf eines Objekts mindestens 2 * str.length()Bytes.

Es gibt eine Methode namens getBytes () . Benutze es weise .

Versuche dies :

Bytes.toBytes(x).length

Angenommen, Sie haben x zuvor deklariert und initialisiert

Verwenden Sie:

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