Mutable boolean field in Java

Question

I need a mutable boolean field in Java (I will return this field via get* method later and it should be possible to modify this field).

Boolean doesn't work because there are no set* methods in the Boolean class (I would say that Boolean is immutable, you can only change the reference, but you can't change the object itself).

I guess I can use Boolean array of size 1. But probably there are more elegant solutions?

Why doesn't Java have such a simple thing?

Answer 1

Immutable classes are easier to work with. They'll never change and there will be no problems with concurrent code. (Basically, there are fewer possibilities to break them.)

If you would like to return a reference to your Boolean value, you can use java.util.concurrent.atomic.AtomicBoolean if you're working with multiple threads or plain old org.apache.commons.lang.mutable.MutableBoolean.

Answer 2

Maybe write yourself a wrapper class

class BooleanHolder {
    public boolean value;
}

Or make a generic holder class (which means you will have to use class Boolean instead of primitive boolean):

class Holder<T> {
    public T value;
}

You then return the wrapper class instead of the value itself, which allows the value inside the wrapper to be modified.

Answer 3

If you are using Java 5 or higher then use AtomicBoolean

Answer 4

You can use a boolean array

final boolean[] values = { false };
values[0] = true;

Answer 5

Why not use the boolean primitive ?

e.g.

private boolean myFlag = false;

public void setMyFlag(boolean flag) {
   myFlag = flag;
}

Note your getter method can return a Boolean if required, due to the magic of autoboxing. This allows easy interchangeability between using primitives and their object equivalents (e.g. boolean vs. Boolean, or int vs. Integer).

So to address your edited responses re. the methods you have available,

public Object getAttribute(String attributeName)

can be implemented by returning an autoboxed boolean,.

Answer 6

What about just using the boolean primitive?

private boolean value;

public void setValue(boolean value) {
    this.value = value;
}

public boolean getValue() {
    return value;
}

Answer 7

The answer I liked most was from Adam to write your own wrapper class... OK

/* Boolean to be passed as reference parameter */
public class Bool {

     private boolean value;

     public Bool() {
         this.value = false;
     }

     public boolean is() {
         return this.value;
     }

     public void setTrue() {
         this.value = true;
     }

     public void setFalse() {
         this.value = false;
     }
 }

Answer 8

If you are using Android, you can use the android.util.Mutable* objects which wrap various primitive values. For example, quoting from the SDK source:

public final class MutableBoolean {
  public boolean value;

  public MutableBoolean(boolean value) {
      this.value = value;
  }
}

Answer 9

Are you really saying that you want callers to be able to modify the object's boolean value by manipulating what gets returned? So that the object and caller would share a reference to it?

Just so I understand, given:

class OddClass {
   private Boolean strangeFlag;
   public Object getAttrbiute(String attributeName) { 
      if (attributeName.equals("strangeflag")) return (Object)strangeFlag; 
      ...
   }
}

And then caller does:

   Boolean manipulableFlag = (Boolean) myOddClass.getAttrbiute ("strangeflag");

And then later, if caller changes the value of manipulableFlag, you want that change to happen in the OddClass instance, just as though caller had instead used a setAttrbiute method.

Is that what you're asking?

In that case, you'd need a holder class, as suggested by Adam.