Java : Char vs String byte size

Question

I was surprised to find that the following code

System.out.println("Character size:"+Character.SIZE/8);
System.out.println("String size:"+"a".getBytes().length);

outputs this:

Character size:2

String size:1

I would assume that a single character string should take up the same (or more ) bytes than a single char.

In particular I am wondering.

If I have a java bean with several fields in it, how its size will increase depending on the nature of the fields (Character, String, Boolean, Vector, etc...) I'm assuming that all java objects have some (probably minimal) footprint, and that one of the smallest of these footprints would be a single character. To test that basic assumption I started with the above code - and the results of the print statements seem counterintuitive.

Any insights into the way java stores/serializes characters vs strings by default would be very helpful.

The length of a string is the number of characters it contains. A character can be encoded in more than one byte. — Oded, Mar 22 '12 at 15:23
The string is most probably UTF-8 encoded, so the "a" takes only one byte. — Niklas B., Mar 22 '12 at 15:23
[The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)](http://www.joelonsoftware.com/articles/Unicode.html) — Oded, Mar 22 '12 at 15:23
@NiklasB. Or rather a fixed width UTF-16 ( UCS-2 ) type format. — kervin, Mar 21 '15 at 00:04

score 10 · Accepted Answer · edited Aug 17 '17 at 13:40

10

getBytes() outputs the String with the default encoding (most likely ISO-8859-1) while the internal character char has always 2 bytes. Internally Java uses always char arrays with a 2 byte char, if you want to know more about encoding, read the link by Oded in the question comments.

edited Aug 17 '17 at 13:40

Andrew Tobilko

48,120
14
91
142

answered Mar 22 '12 at 15:24

Thorsten S.

4,144
27
41

3

For reference, `getBytes()` is not actually telling you the actual memory consumption of the `String`. – Louis Wasserman Mar 22 '12 at 15:25
I do not think this statement of yours is correct: "Internally Java uses always char arrays with a 2 byte char." You can see this link: http://javarevisited.blogspot.com.tr/2012/01/get-set-default-character-encoding.html For me, Java used UTF-8 as default encoding in the code. – Koray Tugay Jan 21 '16 at 09:14
@KorayTugay You are likely mixing up what the internal memory representation of Unicode in Java is (yes, every CharSequence implementation like String are still using 2 byte chars in UTF-16 format) and that Java import or export internal representations (file, network) in specific byte encodings. If you still believe your Java version (which is...?) uses internally UTF-8, how did you prove that ? By the way, the problem of getBytes() is that the function is very old, it was already there in version 1.1 when UTF-8 was not supported yet, so you cannot really predict that it uses UTF-8. – Thorsten S. Jan 22 '16 at 13:16

score 2 · Answer 2 · edited May 23 '17 at 11:53

2

I would like to say what i think,correct me if i am wrong but you are finding the length of the string which is correctly it is showing as 1 as you have only 1 character in the string. length shows the length not the size . length and size are two different things.

check this Link.. you are finding the number of bytes occupied in the wrong way

edited May 23 '17 at 11:53

Community

1
1

answered Mar 22 '12 at 15:29

Nav

10,304
20
56
83

score 0 · Answer 3 · answered Jan 28 '16 at 15:20

I want to add some code first and then a bit of explanation:

import java.nio.charset.Charset;

public class Main {

    public static void main(String[] args) {
        System.out.println("Character size: " + Character.SIZE / 8);
        final byte[] bytes = "a".getBytes(Charset.forName("UTF-16"));
        System.out.println("String size: " + bytes.length);
        sprintByteAsHex(bytes[0]);
        sprintByteAsHex(bytes[1]);
        sprintByteAsHex(bytes[2]);
        sprintByteAsHex(bytes[3]);
    }

    static void sprintByteAsHex(byte b) {
        System.out.print((Integer.toHexString((b & 0xFF))));
    }
}

And the output will be:

Character size: 2
String size: 4
feff061

So what you are actually missing is, you are not providing any parameter to the getBytes method. Probably, you are getting the bytes for UTF-8 representation of the character 'a'.

Well, but why did we get 4 bytes, when we asked for UTF-16? Ok, Java uses UTF-16 internally, then we should have gotten 2 bytes right?

If you examine the output:

feff061

Java actually returned us a BOM: https://en.wikipedia.org/wiki/Byte_order_mark.

So the first 2 bytes: feff is required for signalling that following bytes will be UTF-16 Big Endian. Please see the Wikipedia page for further information.

The remaining 2 bytes: 0061 is the 2 byte representation of the character "a" you have. Can be verified from: http://www.fileformat.info/info/unicode/char/0061/index.htm

So yes, a character in Java is 2 bytes, but when you ask for bytes without a specific encoding, you may not always get 2 bytes since different encodings will require different amount of bytes for various characters.

Alex Stybaev · Answer 4 · 2012-03-23T07:17:19.147

0

well, you have that 1 char in char array has the size of 2 bytes and that your String contains is 1 character long, not that it has 1 byte size.

The String object in Java consists of:

private final char value[];
private final int offset;
private final int count;
private int hash;

only this should assure you that anyway the String object is bigger then char array. If you want to learn more about how object's size you can also read about the object headers and multiplicity factor for char arrays. For example here or here.

edited Mar 23 '12 at 07:17

answered Mar 22 '12 at 16:09

Alex Stybaev

4,623
3
30
44

this doesnt make sense can you try to improve the grammer ... etc ? – jayunit100 Mar 22 '12 at 20:07

score -1 · Answer 5 · answered Mar 22 '12 at 15:24

The SIZE of a Character is the storage needed for a char, which is 16 bit. The length of a string (also the length of the underlying char-array or bytes-array) is the number of characters (or bytes), not a size in bit.

That's why you had do to the division by 8 for the size, but not for the length. The length needs to be multiplied by two.

Also note that you will get other lengths for the byte-array if you specify a different encoding. In this case a transformation to a single- or varying-size encoding was performed when doing getBytes().

See: http://docs.oracle.com/javase/6/docs/api/java/lang/String.html#getBytes(java.nio.charset.Charset)

No, he used `getBytes()`, so what he gets is actually the number of bytes (which is not surprising as well). — Niklas B., Mar 22 '12 at 15:25
Yes this answer is a little off topic and mischaracterizes the question ... I suggest an update. — jayunit100, Mar 24 '12 at 16:41

Java : Char vs String byte size

5 Answers5