Check if primitive has been set

Question

Given a very simple class:

class MyClass {
    int id;
    double value;

    MyClass(int id) {
        this.id = id;
    }

    void setValue(double v) {
        value = v;
    }

    boolean isValueUnassigned() {
        return value == 0;
    }
}

To check if value has not been assigned yet, is it OK if I just do return value == 0; since a double is 0 by default?

Answer 1

You should go for wrapper class for double which is Double. For Double data type default value would be null. So that there would not be any ambiguity. If value is null, then it's not assigned any value.

Answer 2

Well, yes primitive double is set to 0.0 by default. But if you simply do return value == 0; you can't be sure if someone called setValue(0) before, but it is a valid assignment too. If you want to be 100% sure if someone called the setValue() I would suggest something like this:

class MyClass {
    private int id;
    private double value;
    private boolean valueSet; // is false by default 

    public MyClass(int id) {
        this.id = id;
    }

    public void setValue(double v) {
        value = v;
        valueSet = true;
    }

    public boolean isValueSet() {
        return valueSet;
    }
}

Answer 3

Adding to what @Harshal has already said. Code for something like that would look like:

class MyClass {
    private int id;
    private Double value;

    public MyClass(int id) {
        this.id = id;
    }

    public void setValue(double v) {
        value = v;
    }

    public double getValue() {
        //Check for null pointer and return 
        if(value == null)
            return <whatever you want>;

        return value.doubleValue();;
    }

    public boolean isValueSet() {
        return (value == null ? false : true);
    }
}

Answer 4

You can use Double to reinitialize the double using following

class MyClass {
    int id;
    Double value;

MyClass(int id) {
    this.id = id;
}

void setValue(Double v) {
    value = v;
}

boolean isValueUnassigned() {

   return value == null ? false : true;
}
}

Answer 5

Explanation

The main issue here is that, whatever double value you choose, e.g. 0 or -1, it could actually be a valid value set by the user. In which case your application would falsely return that it was not set yet, while it was.

What you need is called a sentinel value, i.e. a special value that indicates this case. Typically there are 3 approaches:

---

Flag

Introduce a simple boolean flag boolean isSet which you initialize to false and set to true once it was set.

This approach is good and really fast. But does not scale well if you, for example, start to introduce hundreds of such values for which you need to represent "not set yet".

double value;
boolean isValueSet = false;

void setValue(double value) {
    this.value = value;
    isValueSet = true;
}

boolean isValueUnassigned() {
    return !isValueSet;
}

---

Object wrapper

Object variables can, additionally to their actual values/instances also refer to null. This can be used as sentinel to indicate the special case.

So you could go for having the value internally represented as Double instead of double, starting with null.

The disadvantage is that an object introduces quite some memory and performance overhead compared to a simple primitive. In this case it does not really matter but if you scale this up to a couple of thousands of them, you would definitely start to feel the impact.

Double value = null;

void setValue(double value) {
    this.value = value; // auto-boxing
}

boolean isValueUnassigned() {
    return value == null;
}

---

Sentinel value

If you application naturally allows that some values can never be used, you can use them as sentinel to indicate the case. A common example would be an age field for which you would not allow the user to set it to negative values. Then you can use, for example -1 to indicate it.

This approach is quite common and efficient. But it obviously is not always applicable and it is also not necessarily the most readable/maintainable approach.

double value = -1;

void setValue(double value) {
    if (value < 0) {
        throw new IllegalArgumentException("Negative values are not allowed");
    }
    this.value = value;
}

boolean isValueUnassigned() {
    return value == -1;
}

Answer 6

The value is assigned when the object is created. You don't need a method to check if the value has been assigned because the answer is always yes.

Answer 7

Found the cleanest and clearest way to express it:

class MyClass {
    int id;
    Optional<Double> value;

    MyClass(int id) {
        this.id = id;
        this.value = Optional.empty();
    }

    void setValue(double v) {
        value = Optional.of(v);
    }

    double getValue() {
        if (isValueUnassigned) {
            throw new RuntimeException("Value has not been assigned");
        }
        return value.get();
    }

    boolean isValueUnassigned() {
        return value.isEmpty();
    }
}

Answer 8

a double value is 0 by default , but you can pass -1 to it .

double value = -1;

for check :

 if (value!= -1) {
    // To Do
 }