I have heard mixed opinions over the amount of memory that a byte takes up in a java program.
I am aware you can store no more than +127 in a java byte, and the documentation says that a byte is only 8 bits but here I am told that it actually takes up the same amount of memory as an int, and therefore is just a Type that helps in code comprehension and not efficiency.
Can anyone clear this up, and would this be an implementation specific issue?
Okay, there's been a lot of discussion and not a lot of code :)
Here's a quick benchmark. It's got the normal caveats when it comes to this kind of thing - testing memory has oddities due to JITting etc, but with suitably large numbers it's useful anyway. It has two types, each with 80 members - LotsOfBytes has 80 bytes, LotsOfInts has 80 ints. We build lots of them, make sure they're not GC'd, and check memory usage:
class LotsOfBytes
{
byte a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
byte b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
byte c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
byte d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
byte e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}
class LotsOfInts
{
int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
int b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
int c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
int d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
int e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}
public class Test
{
private static final int SIZE = 1000000;
public static void main(String[] args) throws Exception
{
LotsOfBytes[] first = new LotsOfBytes[SIZE];
LotsOfInts[] second = new LotsOfInts[SIZE];
System.gc();
long startMem = getMemory();
for (int i=0; i < SIZE; i++)
{
first[i] = new LotsOfBytes();
}
System.gc();
long endMem = getMemory();
System.out.println ("Size for LotsOfBytes: " + (endMem-startMem));
System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));
System.gc();
startMem = getMemory();
for (int i=0; i < SIZE; i++)
{
second[i] = new LotsOfInts();
}
System.gc();
endMem = getMemory();
System.out.println ("Size for LotsOfInts: " + (endMem-startMem));
System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));
// Make sure nothing gets collected
long total = 0;
for (int i=0; i < SIZE; i++)
{
total += first[i].a0 + second[i].a0;
}
System.out.println(total);
}
private static long getMemory()
{
Runtime runtime = Runtime.getRuntime();
return runtime.totalMemory() - runtime.freeMemory();
}
}
Output on my box:
Size for LotsOfBytes: 88811688
Average size: 88.811688
Size for LotsOfInts: 327076360
Average size: 327.07636
0
So obviously there's some overhead - 8 bytes by the looks of it, although somehow only 7 for LotsOfInts (? like I said, there are oddities here) - but the point is that the byte fields appear to be packed in for LotsOfBytes such that it takes (after overhead removal) only a quarter as much memory as LotsOfInts.
class LotsOfBytes { byte a0; } class LotsOfInts { int a0; } there won't be any significant difference
Size for LotsOfBytes: -914712 Average size: -914.712 Size for LotsOfInts: 336000 Average size: 336.0 0Yes, a byte variable in Java is in fact 4 bytes in memory. However this doesn't hold true for arrays. The storage of a byte array of 20 bytes is in fact only 20 bytes in memory.
That is because the Java Bytecode Language only knows two integer number types: ints and longs. So it must handle all numbers internally as either type and these types are 4 and 8 bytes in memory.
However, Java knows arrays with every integer number format. So the storage of short arrays is in fact two bytes per entry and one byte per entry for byte arrays.
The reason why I keep saying "the storage of" is that an array is also an object in Java and every object requires multiple bytes of storage on its own, regardless of the storage that instance variables or the array storage in case of arrays require.
int[] array? Will it be 4[=length] + 4[=int_size]*length(array) + 8_byte_align?
Java is never implementation or platform specific (at least as far as primitive type sizes are concerned). They primitive types are always guaranteed to stay the same no matter what platform you're on. This differs from (and was considered an improvement on) C and C++, where some of the primitive types were platform specific.
Since it's faster for the underlying operating system to address four (or eight, in a 64-bit system) bytes at a time, the JVM may allocate more bytes to store a primitive byte, but you can still only store values from -128 to 127 in it.
A revealing exercise is to run javap on some code that does simple things with bytes and ints. You'll see bytecodes that expect int parameters operating on bytes, and bytecodes being inserted to co-erce from one to another.
Note though that arrays of bytes are not stored as arrays of 4-byte values, so a 1024-length byte array will use 1k of memory (Ignoring any overheads).
I did a test using http://code.google.com/p/memory-measurer/ Note that I am using 64-bit Oracle/Sun Java 6, without any compression of references etc.
Each object occupies some space, plus JVM needs to know address of that object, and "address" itself is 8 bytes.
With primitives, looks like primitives are casted to 64-bit for better performance (of course!):
byte: 16 bytes,
int: 16 bytes,
long: 24 bytes.
With Arrays:
byte[1]: 24 bytes
int[1]: 24 bytes
long[1]: 24 bytes
byte[2]: 24 bytes
int[2]: 24 bytes
long[2]: 32 bytes
byte[4]: 24 bytes
int[4]: 32 bytes
long[4]: 48 bytes
byte[8]: 24 bytes => 8 bytes, "start" address, "end" address => 8 + 8 + 8 bytes
int[8]: 48 bytes => 8 integers (4 bytes each), "start" address, "end" address => 8*4 + 8 + 8 bytes
long[8]: 80 bytes => 8 longs (8 bytes each), "start" address, "end" address => 8x8 + 8 + 8 bytes
And now guess what...
byte[8]: 24 bytes
byte[1][8]: 48 bytes
byte[64]: 80 bytes
byte[8][8]: 240 bytes
P.S. Oracle Java 6, latest and greatest, 64-bit, 1.6.0_37, MacOS X
It depends on how the JVM applies padding etc. An array of bytes will (in any sane system) be packed into 1-byte-per-element, but a class with four byte fields could either be tightly packed or padded onto word boundaries - it's implementation dependent.
What you've been told is exactly right. The Java byte code specification only has 4-byte types and 8-byte types.
byte, char, int, short, boolean, float are all stored in 4 bytes each.
double and long are stored in 8 bytes.
However byte code is only half the story. There's also the JVM, which is implementation-specific. There's enough info in Java byte code to determine that a variable was declared as a byte. A JVM implementor may decide to use only a byte, although I think that is highly unlikely.
You could always use longs and pack the data in yourself to increase efficiency. Then you can always gaurentee you'll be using all 4 bytes.
byte = 8bit = one byte defined by the Java Spec.
how much memory an byte array needs is not defined by the Spec, nor is defined how much a complex objects needs.
For the Sun JVM I documented the rules: https://www.sdn.sap.com/irj/sdn/weblogs?blog=/pub/wlg/5163
See my MonitoringTools at my site (www.csd.uoc.gr/~andreou)
class X {
byte b1, b2, b3...;
}
long memoryUsed = MemoryMeasurer.measure(new X());
(It can be used for more complex objects/object graphs too)
In Sun's 1.6 JDK, it seems that a byte indeed takes a single byte (in older versions, int ~ byte in terms of memory). But note that even in older versions, byte[] were also packed to one byte per entry.
Anyway, the point is that there is no need for complex tests like Jon Skeet's above, that only give estimations. We can directly measure the size of an object!
Just wanted to point out that the statement
you can store no more than +127 in a java byte
is not truly correct.
You can always store 256 different values in a byte, therefore you can easily have your 0..255 range as if it were an "unsigned" byte.
It all depends on how you handle those 8 bits.
Example:
byte B=(byte)200;//B contains 200
System.out.println((B+256)%256);//Prints 200
System.out.println(B&0xFF);//Prints 200
Objects, References and Wrapper Classes. Minimum object size is 16 bytes for modern 64-bit JDK since the object has 12-byte header, padded to a multiple of 8 bytes.
This is a reason why byte, short, and int take equal memory size:
byte b = 1;//12+1 = 13 * padding to a multiple of 8 bytes = 16
:
byte b = 1;//16: 12 + 1 = 13 * padding = 16
boolean bo = false;//16 ...
short s = 1;//16 ...
char c = 1;//16 ...
int i = 1;//16: 12 + 4 = 16 * padding = 16
long l = 1;//24: 12 + 8 = 20 * padding = 24
float f = 1;//16 ...
double d = 1;//24 ...
But another effect will be when we use our primitives in the array. In this case, the array takes 16 bytes as the object for itself, and all other bytes are multiplied by the amount of the cell. (Do not forget about padding):
byte[] b1 = new byte[0];//16 - empty object
byte[] b2 = new byte[1];//24 - 16+1 = 17 * padding = 24
byte[] b3 = new byte[2];//24 ...
byte[] b4 = new byte[3];//24
byte[] b5 = new byte[4];//24
byte[] b6 = new byte[5];//24
byte[] b7 = new byte[6];//24
byte[] b8 = new byte[7];//24 ...
byte[] b9 = new byte[8];//24 - 16+8 = 24 * padding = 24
byte[] b10 = new byte[9];//32 - 16+9 = 25 * padding = 32
byte[] b1000 = new byte[1000];//1016 - 16 + 1000 * 1 = 1016
int[] i1000 = new int[1000];//4016 - 16 + 1000 * 4 = 4016
It appears that the answer is likely to depend on your JVM version and probably also the CPU architecture you're running on. The Intel line of CPUs do byte manipulation efficiently (due to its 8-bit CPU history). Some RISC chips require word (4 byte) alignment for many operations. And memory allocation can be different for variables on the stack, fields in a class, and in an array.
