L'appel de Java varargs méthode avec un seul argument null?

Le problème est que lorsque vous utilisez le littéral null, Java ne sait pas de quel type il est censé être. Il pourrait être un Objet nul, ou peut-être un Objet null tableau. Pour un seul argument qu'elle assume ce dernier.

Vous avez deux choix. Fonte le null explicitement pour Objet ou appelez la méthode utilise un typage fort variable. Voir l'exemple ci-dessous:

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));
   }
}

De sortie:

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

Un Cas de Test pour l'illustrer:

Le code Java avec un vararg méthode de prise de déclaration (qui se trouve être statique):

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;
    }
}

Ce code Java (un JUnit4 cas de test) appelle le ci-dessus (nous utilisons le test de ne pas tester n'importe quoi, juste pour générer de la puissance de sortie):

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"}));
    }
}

L'exécution de cette comme un test JUnit rendements:

sendNothing(): a reçu un 'x' est un tableau de taille 0 
sendNullWithNoCast(): a reçu un 'x' est null 
sendNullWithCastToString(): a reçu un 'x' est un tableau de taille 1 
sendNullWithCastToArray(): a reçu un 'x' est null 
sendOneValue(): a reçu un 'x' est un tableau de taille 1 
sendThreeValues(): a reçu un 'x' est un tableau de taille 3 
sendArray(): a reçu un 'x' est un tableau de taille 3 

De le rendre plus intéressant, nous allons l'appeler le receive() fonction de Groovy 2.1.2 et voir ce qui se passe. Il s'avère que les résultats ne sont pas les mêmes! Cela peut être un bug si.

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"
    }

}

L'exécution de cette comme un test JUnit rendements suivants, à la différence de Java en caractères gras.

sendNothing(): a reçu un 'x' est un tableau de taille 0 
sendNullWithNoCast(): a reçu un 'x' est null 
sendNullWithCastToString(): a reçu un 'x' est null 
sendNullWithCastToArray(): a reçu un 'x' est null 
sendOneValue(): a reçu un 'x' est un tableau de taille 1 
sendThreeValues(): a reçu un 'x' est un tableau de taille 3 
sendArray(): a reçu un 'x' est un tableau de taille 3 

Je préfère

foo(new Object[0]);

pour éviter de pointeur Null exceptions.

Espère que cela aide.