null - argumentos - ¿Llamar al método varargs de Java con un solo argumento nulo?

vararg kotlin

Question

Si tengo un método vararg Java foo(Object ...arg) y llamo foo(null, null) , tengo ambos arg[0] y arg[1] como null s. Pero si llamo a foo(null) , arg sí es nulo. ¿Por qué está pasando esto?

¿Cómo debo llamar a foo para que foo.length == 1 && foo[0] == null sea true ?

Answer 1

El problema es que cuando usas el literal nulo, Java no sabe qué tipo se supone que es. Podría ser un Objeto nulo, o podría ser una matriz de Objeto nulo. Para un argumento único, asume lo segundo.

Tienes dos opciones. Emitir el nulo explícitamente a Object o llamar al método usando una variable fuertemente tipada. Vea el ejemplo a continuación:

public class Temp{
public static void main(String[] args){
foo("a", "b", "c");
foo(null, null);
foo((Object)null);
Object bar = null;
foo(bar);
}
private static void foo(Object...args) {
System.out.println("foo called, args: " + asList(args));
}
}

Salida:

foo called, args: [a, b, c]
foo called, args: [null, null]
foo called, args: [null]
foo called, args: [null]

Answer 2

Esto se debe a que se puede invocar un método varargs con una matriz real en lugar de una serie de elementos de matriz. Cuando le proporciona el null ambiguo por sí mismo, asume que el null es un Object[] . Lanzar el null a Object arreglará esto.

Answer 3

Necesitas un elenco explícito para Object :

foo((Object) null);

De lo contrario, se supone que el argumento es la matriz completa que representan los varargs.

Answer 4

Un caso de prueba para ilustrar esto:

El código de Java con una declaración de método vararg-taking (que pasa a ser estático):

public class JavaReceiver {
public static String receive(String... x) {
String res = ((x == null) ? "null" : ("an array of size " + x.length));
return "received ''x'' is " + res;
}
}

Este código Java (un caso de prueba JUnit4) llama a lo anterior (estamos utilizando el caso de prueba para no probar nada, solo para generar algún resultado):

import org.junit.Test;
public class JavaSender {
@Test
public void sendNothing() {
System.out.println("sendNothing(): " + JavaReceiver.receive());
}
@Test
public void sendNullWithNoCast() {
System.out.println("sendNullWithNoCast(): " + JavaReceiver.receive(null));
}
@Test
public void sendNullWithCastToString() {
System.out.println("sendNullWithCastToString(): " + JavaReceiver.receive((String)null));
}
@Test
public void sendNullWithCastToArray() {
System.out.println("sendNullWithCastToArray(): " + JavaReceiver.receive((String[])null));
}
@Test
public void sendOneValue() {
System.out.println("sendOneValue(): " + JavaReceiver.receive("a"));
}
@Test
public void sendThreeValues() {
System.out.println("sendThreeValues(): " + JavaReceiver.receive("a", "b", "c"));
}
@Test
public void sendArray() {
System.out.println("sendArray(): " + JavaReceiver.receive(new String[]{"a", "b", "c"}));
}
}

Ejecutando esto como una prueba JUnit produce:

sendNothing(): received ''x'' is an array of size 0 sendNullWithNoCast(): received ''x'' is null sendNullWithCastToString(): received ''x'' is an array of size 1 sendNullWithCastToArray(): received ''x'' is null sendOneValue(): received ''x'' is an array of size 1 sendThreeValues(): received ''x'' is an array of size 3 sendArray(): received ''x'' is an array of size 3

Para que esto sea más interesante, llamemos a la función receive() de Groovy 2.1.2 y veamos qué sucede. ¡Resulta que los resultados no son los mismos! Aunque esto puede ser un error.

import org.junit.Test
class GroovySender {
@Test
void sendNothing() {
System.out << "sendNothing(): " << JavaReceiver.receive() << "/n"
}
@Test
void sendNullWithNoCast() {
System.out << "sendNullWithNoCast(): " << JavaReceiver.receive(null) << "/n"
}
@Test
void sendNullWithCastToString() {
System.out << "sendNullWithCastToString(): " << JavaReceiver.receive((String)null) << "/n"
}
@Test
void sendNullWithCastToArray() {
System.out << "sendNullWithCastToArray(): " << JavaReceiver.receive((String[])null) << "/n"
}
@Test
void sendOneValue() {
System.out << "sendOneValue(): " + JavaReceiver.receive("a") << "/n"
}
@Test
void sendThreeValues() {
System.out << "sendThreeValues(): " + JavaReceiver.receive("a", "b", "c") << "/n"
}
@Test
void sendArray() {
System.out << "sendArray(): " + JavaReceiver.receive( ["a", "b", "c"] as String[] ) << "/n"
}
}

Ejecutar esto como una prueba JUnit produce lo siguiente, con la diferencia de que Java se resalta en negrita.

sendNothing(): received ''x'' is an array of size 0 sendNullWithNoCast(): received ''x'' is null sendNullWithCastToString(): received ''x'' is null sendNullWithCastToArray(): received ''x'' is null sendOneValue(): received ''x'' is an array of size 1 sendThreeValues(): received ''x'' is an array of size 3 sendArray(): received ''x'' is an array of size 3

Answer 5

yo prefiero

foo(new Object[0]);

para evitar excepciones del puntero nulo.

Espero eso ayude.