Octets d'une chaîne de caractères en Java

Question

En Java, si j'ai une chaîne x comment puis-je calculer le nombre d'octets dans cette chaîne ?

Answer 1

Une chaîne de caractères est une liste de caractères (c'est-à-dire les points de code). Le nombre d'octets nécessaires pour représenter la chaîne de caractères dépend entièrement de l'encodage que vous utilisez pour le transformer en octets. .

Cela dit, vous pouvez transformer la chaîne de caractères en un tableau d'octets, puis examiner sa taille comme suit :

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

Vous voyez donc que même une simple chaîne "ASCII" peut avoir un nombre différent d'octets dans sa représentation, selon l'encodage utilisé. Utilisez le jeu de caractères qui vous intéresse dans votre cas, en tant qu'argument de la fonction getBytes() . Et ne tombez pas dans le piège de supposer que UTF-8 représente chaque comme un seul octet, car ce n'est pas vrai non plus :

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

(Notez que si vous ne fournissez pas d'argument pour le jeu de caractères, l'option jeu de caractères par défaut est utilisé. Cela peut être utile dans certains contextes, mais en général vous devriez éviter de dépendre des valeurs par défaut, et toujours utiliser un jeu de caractères explicite lorsque l'encodage/décodage est requis).

Answer 2

Si vous utilisez des références 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 d'autres termes :

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

Sur une VM 32 bits ou une VM 64 bits avec des OOPs compressées (-XX:+UseCompressedOops), les références sont de 4 octets. Donc le total serait :

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

Cela ne prend pas en compte les références à l'objet chaîne.

Answer 3

Según Comment convertir des chaînes de caractères en tableaux d'octets UTF8 en Java ? :

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

Answer 4

A String alloue une certaine quantité d'octets en mémoire. Peut-être que vous cherchez quelque chose comme sizeof("Hello World") qui renverrait le nombre d'octets alloués par la structure de données elle-même ?

En Java, il n'y a généralement pas besoin d'un fichier sizeof car nous n'allouons jamais de mémoire pour stocker une structure de données. Nous pouvons jeter un coup d'œil à la String.java pour une estimation approximative, et nous voyons quelques 'int', quelques références et un char[] . Le site Spécification du langage Java définit, qu'une char va de 0 à 65535, donc deux octets sont suffisants pour garder un seul caractère en mémoire. Mais une JVM n'est pas obligée de stocker un caractère dans 2 octets, elle doit seulement garantir que l'implémentation de la fonction char peut contenir des valeurs de l'intervalle défini.

Alors sizeof n'a vraiment aucun sens en Java. Mais, en supposant que nous ayons un grand String et un char alloue deux octets, alors l'empreinte mémoire d'une String est au moins 2 * str.length() en octets.

Answer 5

Il y a une méthode appelée getBytes() . Utilisez-le à bon escient.