Bit Flags VS Boolean Flags

Question

Hi here are two code snippets:
One with boolean flags;
public class BooleanFlags {
     private boolean _flag1 = false;
     private boolean _flag2 = false;
     private boolean _flag3 = false;
     private boolean _flag4 = false;
     public boolean isFlag1() {
          return this._flag1;
     public void setFlag1(boolean flag1) {
          this._flag1 = flag1;
     public boolean isFlag2() {
          return this._flag2;
     public void setFlag2(boolean flag2) {
          this._flag2 = flag2;
     public boolean isFlag3() {
          return this._flag3;
     public void setFlag3(boolean flag3) {
          this._flag3 = flag3;
     public boolean isFlag4() {
          return this._flag4;
     public void setFlag4(boolean flag4) {
          this._flag4 = flag4;
}Another with bit flags
public class BitFlags {
     static final int _FLAG1 = 1;
     static final int _FLAG2 = 2;
     static final int _FLAG3 = 4;
     static final int _FLAG4 = 8;
     private int _flags = 0;
     public int getFlags() {
          return this._flags;
     public void setFlags(int flags) {
          this._flags = flags;
}Testing code
public class TestFlags {
     public static void main(String[] args) {
          // bit
          BitFlags t = new BitFlags();
          t.setFlags(t.getFlags() | BitFlags._FLAG1);
          t.setFlags(t.getFlags() | BitFlags._FLAG2);
          if ((t.getFlags() & BitFlags._FLAG2) == BitFlags._FLAG2) {
               System.out.println("FLAG2");
          //boolean
          BooleanFlags bf = new BooleanFlags();
          bf.setFlag1(true);
          bf.setFlag2(true);
          if ( bf.isFlag2() ) {
               System.out.println("FLAG2");
}I counted the number bytes used by each classes.
Each character of a class name weighs 3 bytes each.
For a default package BitFlags.class file weighs
for 1 flag 519 bytes
for 2 flags 549 bytes
for 3 flags 579 bytes
for 4 flags 609 bytes
So that's 30 bytes per flags.
BooleanFlags.class file weighs
for 1 flag 484 bytes
for 2 flag 686 bytes
for 3 flags 888 bytes
for 4 flags 1090 bytes
So that's 202 bytes per flags.
I don't know though how the size of the class file is correlated with the memory used at run time. Apparently boolean flags suck.
But wait.
A) Which one is the most efficient memory wise at run time?
Degrees of freedom:
-the number of flags used,
-the number of instances that will be created.
An important question needs to be answered, that is whether a boolean literal weighs indeed a 1 bit of memory or more. I don't know.
When reasoning from a conceptual point of view, the memory usage for bit flags will take 4 bytes per instance for the _flags field and a constant 4 bytes per static flag definition,
N > 0, X > 0
32 * N + X*32 = A bits
Boolean flags take 1 bit per instance per flag
1 * N * X = B bits
So if we want A > B
32N >(N-32) X
If N > 32 then 32N/(N-32) > X
If N = 32 then INF>X
If N < 32 then 32N/(N-32) < X
To have A > B we need
N = 1 : 0 < X < INF
N = 31 : 0 < X < INF
N = 32 : 0< X < INF
N = 33 : 0 < X < 1056
N = 40 : 0 < X < 160
N = 50 : 0 < X < 89
N = 100 : 0 < X < 48
N = 10000 : 0 < X < 33
As you can guess, as N goes to infinite, X goes to 32.
For a very large number of instances, boolean flags will take less memory than bit flags if you have less than 32 flags (dual will take more memory if have more than 32 flags) Boolean flags always beat bit flags for less than 33 instances
Now I don't know what really happens in practice. Because one should take heed of the way classes are managed. The code for getting boolean flags takes a lot of room. Now if that code is loaded once. That's ok. But if the get and set methods for every bit flags are loaded for every instance. Then that's bad.
A solution to this would be to use public members and remove getters and setters.
The most important issue though is how boolean literal are managed by the memory.
From a purely aesthetic perspective, the usage of boolean flag is nicer. Testing the value of a bit flag is ugly.
Cheers

Answer 1

The hardware level is irrelevent. If the best you can
do is "look for multiple boolean variables in the same
class and pack them into a single byte," why can't
this be done by JVM writers for you?
Although tecnically possible, I suspect only that someone who didn't know what they were doing would implement it that way.
First keep in mind that this is something the VM must do. The compiler has nothing to do with. And it does mean that just for the VM to access values (not via java) that the code will be slower. It is because of this that C/C++ language allows developers to decide whether to pack integer numerics or not.
Second consider the following...
    void myMethod()
       boolean b = true;
          boolean b1_1 = true;
          String s1 = "test";
          boolean b1_2 = true;
          String s2 = "test";
          boolean b2_1 = true;
          boolean b2_1 = true;
    }Now the compiler is going to render the above by using stack frame references as
#1 = b
#2 = b1_1 and s2
#3 = s1 and b2_1
#4 = b1_2 and b2_1
So now the VM is going to have to know that #1 holds all the bits and sometimes those bits are used by #2 and sometime not.
Now one could write code that would do that. But I would be a lot slower and I suspect it would actually take more space due to maintenance information information needed to handle it all.
And the result would be that all Java apps would be slower and only a few (definitely less than 1%) would save any space. I don't think a reasonable VM vendor would take that path.