Missing value in Java

Question

What is the statement that can be used in Java to represent a missing value of a variable. for instance I want to write a code:

if (a>=23)
 income = pay_rate;         


        

Answer 1

You need to Initialize varible with null

Double income = null;
if (a>=23) 
{
   income = pay_rate; 
}

Answer 2

You can do it following way:

public abstract class Nullable extends Number {

    protected final boolean isNA;


    protected Nullable(boolean isNA) {
        this.isNA = isNA;
    }

    public boolean isNA() {
        return isNA;
    }
}


public final class NullableInt extends Nullable {

    public static final NullableInt NA = new NullableInt(0, true);

    private final int value;

    public NullableInt(int value, boolean isNA) {
        super(isNA);
        this.value = value;
    }

    public static NullableInt of(int value) {
        return new NullableInt(value, false);
    }

    public int getValue() {
        if (!isNA) {
            return value;
        }
        throw new RuntimeException("Value is NA");
    }

    @Override
    public int intValue() {
        return getValue();
    }

    @Override
    public long longValue() {
        return getValue();
    }

    @Override
    public float floatValue() {
        return getValue();
    }

    @Override
    public double doubleValue() {
        return getValue();
    }
}

public class Test {

    public static void main(String[] args) {
        NullableInt[] nullableInts = new NullableInt[3];
        nullableInts[0] = NullableInt.of(1);
        nullableInts[1] = NullableInt.of(2);
        nullableInts[2] = NullableInt.NA;

        System.out.println(Arrays.toString(nullableInts));
    }
}

Answer 3

you could try this as well, maybe just the way I like to do it, but up to you :p

if(a >= 23){
    income = payRate;
} else{
    income = null;
}

rather than setting it to null by default, you set it to null after it checks what a is. also, make sure income is either an Integer or Double

Answer 4

Integer income = null;
if (a >= 23) {
  income = payRate; // underscores are generally considered bad convention in Java
}

Answer 5

As mentioned in other ans here, you can use a boxed type. But I ll recommend look for the valid values for your data and choose any invalid value for missing. In your specific case of income, which cannot be negative, so you can choose -1.

The reason to avoid boxed type is performance. I am not against using them but if you can work without them then there is no need to use them.

For the cases where most of +ve and -ve values are valid values, use eitherInteger.MAX_VALUE or Integer.MIN_VALUE as your missing value. You ll just loose one value of all the available value range.

NOTE: Auto-boxing (converting implicitly from primitive to boxed type and vice-versa) is a good feature but can lead to some performance issues which are difficult to debug and find.

Answer 6

There is a lot of bad advice in this thread. First let me address why you should not be going for some of the suggested approaches.

1. Using wrapper types and null

Integer income = null;
if (a >= 23) {
  income = payRate; 
}

Java has auto-unboxing. What if you somewhere accidentally use income in a place where Java had to auto-unbox it? The compiler cannot catch this error and your code will blow up at runtime.

Secondly, the "nullability" of income is not part of income's type. As a result, it's up to the programmer to be careful about checking it for null every time it is used. If he forgets to perform this check, compiler will not complain, but you will get NullPointerExceptions at runtime.

2. Using sentinel values to denote exceptional conditions

int income = Integer.MAX_VALUE;
if (a >= 23) {
  income = payRate;
}

This approach shares the second drawback of null approach. Even worse, in this case, instead of throwing an exception, computation will continue even in erroneous conditions, since Integer.MAX_VALUE is a valid int, leading to possible disastrous outcomes.

---

So how should you deal with this?

Use a data type that:

• has "nullability" expressed in its type.
• does not involve conditional checks such as in above two approaches.
• ensures at compile time that the data is not being accessed in illegal state.

Maybe (also known as Option) fits the bill. (@Bahribayli already suggested this. I am expanding on it.) See the data definition here.

And this how you would use it in your case:

Maybe<Integer> income = Nothing.value();
if (a >= 23) {
  income = Just.of(payRate);
}

There is a library named Functional Java that provides this abstraction. If you have any further questions regarding the use of this data type, I will be happy to answer them.