D'obtenir la taille de la Chaîne w/ encodage en octets sans avoir à les convertir byte[]

Ici est apparemment un travail de mise en œuvre:

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
public class TestUnicode {
private final static int ENCODE_CHUNK = 100;
public static long bytesRequiredToEncode(final String s,
final Charset encoding) {
long count = 0;
for (int i = 0; i < s.length(); ) {
int end = i + ENCODE_CHUNK;
if (end >= s.length()) {
end = s.length();
} else if (Character.isHighSurrogate(s.charAt(end))) {
end++;
}
count += encoding.encode(s.substring(i, end)).remaining() + 1;
i = end;
}
return count;
}
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.appendCodePoint(11614);
sb.appendCodePoint(1061122);
sb.appendCodePoint(2065);
sb.appendCodePoint(1064124);
}
Charset cs = StandardCharsets.UTF_8;
System.out.println(bytesRequiredToEncode(new String(sb), cs));
System.out.println(new String(sb).getBytes(cs).length);
}
}

La sortie est:

1400
1400

Dans la pratique, je voudrais augmenter ENCODE_CHUNK à 10MChars.

Probablement légèrement moins efficace que le brettw de la réponse, mais plus simple à mettre en œuvre.

OriginalL'auteur elhefe

Ok, c'est très brut. Je l'avoue, mais ce genre de choses est caché par la JVM, nous avons donc de creuser un peu. Et transpirer un peu.

Tout d'abord, nous voulons que le réel char[] que le dos d'une Chaîne sans en faire une copie. Pour ce faire, nous devons utiliser la réflexion pour obtenir le champ "valeur":

char[] chars = null;
for (Field field : String.class.getDeclaredFields()) {
if ("value".equals(field.getName())) {
field.setAccessible(true);
chars = (char[]) field.get(string); //<--- got it!
break;
}
}

Ensuite, vous devez mettre en œuvre une sous-classe de java.nio.ByteBuffer. Quelque chose comme:

class MyByteBuffer extends ByteBuffer {
int length;            
//Your implementation here
};

Ignorer tous les getters, de mettre en œuvre tous les mettre méthodes comme put(byte) et putChar(char) etc. À l'intérieur de quelque chose comme put(byte), incrémenter longueur par 1, à l'intérieur de put(byte[]) incrément longueur par la longueur du tableau. Pour l'obtenir? Tout ce qui est à faire, vous ajoutez de la taille de ce qu'il est à longueur. Mais vous n'êtes pas tout stocker dans votre ByteBuffer, vous êtes juste de comptage et de jeter, donc aucun espace n'est prise. Si vous point d'arrêt de la put méthodes, vous pouvez probablement trouver lesquels vous avez réellement besoin de mettre en œuvre. putFloat(float) est probablement pas utilisé, par exemple.

Maintenant pour la grande finale, mettant tous ensemble:

MyByteBuffer bbuf = new MyByteBuffer();         //your "counting" buffer
CharBuffer cbuf = CharBuffer.wrap(chars);       //wrap your char array
Charset charset = Charset.forName("UTF-8");     //your charset goes here
CharsetEncoder encoder = charset.newEncoder();  //make a new encoder
encoder.encode(cbuf, bbuf, true);               //do it!
System.out.printf("Length: %d\n", bbuf.length); //pay me US$1,000,000

OriginalL'auteur brettw