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

Une chaîne 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 dépend entièrement de l'encodage que vous utilisez pour le 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 un simple "ASCII" chaîne peut avoir un nombre différent d'octets dans sa représentation, en fonction de quel encodage est utilisé. Utiliser n'importe quel jeu de caractères qui vous intéresse pour votre cas, en tant qu'argument à getBytes(). Et ne pas tomber dans le piège de supposer que l'UTF-8 représente chaque personnage comme un seul octet, comme 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 jeu de caractères de l'argument, la plate-forme jeu de caractères par défaut est utilisé. Cela peut être utile dans certains contextes, mais en général, vous devriez éviter en fonction des paramètres par défaut, et toujours utiliser explicitement un jeu de caractères lors de l'encodage/décodage est nécessaire.)

Le pédant réponse (mais pas nécessairement la plus utile, en fonction de ce que vous voulez faire avec le résultat) est:

string.length() * 2

Java, les chaînes de caractères sont stockées physiquement dans UTF-16BE codage, qui utilise 2 octets par unité de code, et String.length() mesures de la longueur de code UTF-16 unités, donc c'est équivalent à:

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

Et cela vous indiquera la taille de l'intérieur de l' char tableau, dans octets.

Remarque: "UTF-16" donnera un résultat différent de "UTF-16BE" que l'ancien de l'encodage insérer un BOM, l'ajout de 2 octets pour la longueur du tableau.

Un String instance alloue une certaine quantité d'octets en mémoire. Peut-être que vous êtes à la recherche de quelque chose comme sizeof("Hello World") qui renvoie le nombre d'octets alloués par le discbased lui-même?

En Java, il n'y a généralement pas besoin d'un sizeof fonction, parce que nous n'avons jamais allouer de la mémoire pour stocker une structure de données. Nous pouvons avoir un regard sur le String.java fichier pour une estimation approximative, et nous voyons des "int", des références et une char[]. Le Java langage de spécification définit, que char varie de 0 à 65535, de sorte que deux octets sont suffisantes pour garder un seul caractère dans la mémoire. Mais une JVM ne pas avoir à stocker un char dans les 2 octets, il n'y a plus de garantir que la mise en œuvre de char peuvent contenir des valeurs de l'définit gamme.

Donc sizeof n'a pas vraiment de sens en Java. Mais, à supposer que nous avons une grande Chaîne et un char alloue deux octets, l'empreinte mémoire d'un String objet est d'au moins 2 * str.length() en octets.

Essayez ceci :

Bytes.toBytes(x).length

En supposant que vous avez déclaré et initialisé x avant