Java 3 dots parameter (varargs) behavior when passed no arguments or null

Question

I tried this and get weird behavior from JAVA, can someone explain this for me?

boolean testNull(String... string) {
    if(string == null) {
        return true;
    } else {
        System.out.println(string.getClass());
        return false;
    }
}

boolean callTestNull(String s) {
    return testNull(s);
}

Then I have test case:

    @Test
    public void test_cases() {
        assertTrue(instance.testNull(null)); // NULL
        assertFalse(instance.testNull()); // NOT NULL
        assertFalse(instance.callTestNull(null)); // NOT NULL
    }

The question is if I call testNull() directly with parameter null, I will get true back, but if call callTestNull() with null, which calls testNull(), it tells me the parameter is not null, but empty array.

I meant in terms of Java terminology. But yes, the character "..." is indeed called ellipsis. More info on programming use here en.wikipedia.org/wiki/Ellipsis_(programming_operator) — eldris
– eldris, Commented Jul 17, 2013 at 15:02

Community · Accepted Answer · 2020-06-20 09:12:55Z

The question is if I call testNull() directly with parameter null, I will get true back, but if call callTestNull() with null, which calls testNull(), it tells me the parameter is not null, but empty array.

Yes. If you call it with an argument with a compile-time type of String, the compiler knows that can't be a String[], so it wraps it within a string array. So this:

String x = null;
testNull(x);

is equivalent to:

String x = null;
testNull(new String[] { x });

At this point, the (misleadingly-named) string parameter will have a non-null value - instead, it will refer to an array of size 1 whose sole element is a null reference.

However, when you use the null literal directly in the method call, that's directly convertible to String[], so no wrapping is performed.

From JLS section 15.12.4.2:

If the method being invoked is a variable arity method m, it necessarily has n > 0 formal parameters. The final formal parameter of m necessarily has type T[] for some T, and m is necessarily being invoked with k ≥ 0 actual argument expressions.

If m is being invoked with k ≠ n actual argument expressions, or, if m is being invoked with k = n actual argument expressions and the type of the k'th argument expression is not assignment compatible with T[], then the argument list (e1, ..., en-1, en, ..., ek) is evaluated as if it were written as (e1, ..., en-1, new |T[]| { en, ..., ek }), where |T[]| denotes the erasure (§4.6) of T[].

(Emphasis mine.)

The bit I've emphasized is why the wrapping only happens when the compile-time type of the argument is String, not the null type.

Collectives™ on Stack Overflow

Java 3 dots parameter (varargs) behavior when passed no arguments or null

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related