octets d'une chaîne de caractères en java?

une chaîne de caractères est une liste de caractères (i.e. points de code). Le nombre d'octets pris pour représenter la chaîne dépend entièrement du codage que vous utilisez pour la transformer en octets .

cela dit, vous pouvez transformer la chaîne en un tableau d'octets, puis regarde 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"

donc vous voyez, même une simple chaîne" ASCII " peut avoir un nombre différent d'octets dans sa représentation, en fonction de codage est utilisé. Utilisez le jeu de caractères qui vous intéresse pour votre cas, comme argument pour getBytes() . Et ne tombez pas dans le piège de supposer que UTF-8 représente chaque comme un octet simple, 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 un argument de jeu de caractères, le jeu de caractères par défaut de la plate-forme est utilisé. Cela peut être utile dans certains contextes, mais en général, vous devez éviter de dépendre des valeurs par défaut, et toujours utiliser un jeu de caractères explicites lorsque l'encodage/décodage est requis.)

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és (- XX:+UseCompressedOops), les références sont de 4 octets. Ainsi le total serait:

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

ceci ne tient pas compte des références à l'objet string.

la réponse pédante (bien que pas nécessairement la plus utile, selon ce que vous voulez faire avec le résultat) est:

string.length() * 2

les chaînes Java sont physiquement stockées dans l'encodage UTF-16BE , qui utilise 2 Octets par unité de code, et String.length() mesure la longueur en unités de code UTF-16, ce qui est équivalent à:

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

et cela vous indiquera la taille du tableau interne char , en octets .

Note: "UTF-16" donnera un résultat différent de "UTF-16BE" car l'ancien encodage insérera un BOM , ajoutant 2 octets à la longueur du tableau.

Selon Comment faire pour convertir des Chaînes et de l'UTF8 tableaux d'octets en Java :

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

Un String instance alloue une certaine quantité d'octets en mémoire. Peut-être que vous regardez quelque chose comme sizeof("Hello World") qui retournerait 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'une fonction sizeof , parce que nous n'affectons jamais de mémoire pour stocker une structure de données. Nous pouvons jeter un coup d'oeil au fichier String.java pour une estimation approximative, et nous voyons quelques "int", quelques références et un char[] . Le Java language specification définit qu'un char varie de 0 à 65535, donc deux octets sont suffisants pour garder un seul caractère en mémoire. Mais une JVM ne doit pas stocker un char en 2 octets, elle doit seulement garantir que l'implémentation de char peut contenir des valeurs de la plage définie.

donc sizeof n'a vraiment aucun sens en Java. Mais, en supposant que nous avons une grande chaîne et un char allocs deux octets, l'empreinte mémoire d'un String l'objet est au moins 2 * str.length() en octets.

il y a une méthode appelée getBytes () . Utiliser à bon escient .

essayez ceci:

Bytes.toBytes(x).length

en supposant que vous avez déclaré et initialisé x Avant