Java multiples de longueur variable en argument

Seul le dernier Paramètre est autorisé à être de Longueur variable:

String prepareStatement(String[] columnNames, String... values)

Chaîne... est égal à String[] dans ce cas, vous pouvez insérer une Chaîne de caractères[] pour le premier paramètre, et il suffit de vérifier si son vide ou combien de temps il est.

Modifier à votre Edition

Si vous avez vraiment besoin d'une entrée pour tous vos Chaînes en tant que Paramètres, je vous recommande de le définir vraiment rare de Chaîne pour séparer les entrées:

static String prepareStatement(String... params)
{
    String ret = "";
    boolean valueInput = false;
    for(String s : params)
    {
        if(s.equals("MyReallyUncommonSeperateString"))
        {
            valueInput = true;
            ret+="\nvalues\n";//visual delimiter of columnNames and Values
        }
        else if(valueInput)
        {
            //handling of your value inputs
            ret+=s; //example handling, concatenate everything
        }
        else
        {
            //handling of your columnnames
            ret+=s; //example handling, concatenate everything
        }
    }
    return ret;
}

Vous pouvez l'appeler:

System.out.println(prepareStatement("a","b","c","d","e","MyReallyUncommonSeperateString","f","g","h","i","j","k"));

De sortie:

abcde
values
fghijk

Une autre façon est de donner la longueur de la columnNames comme paramètre:

static String prepareStatement(int length, String... params)
{
    String ret = "";
    for(int i = 0; i < length; i++){
        //handling of columnnames
        String colName = params[i];
        //do something with colName

        ret+=colName; //example handling, concatenate everything
    }
    ret+="\nvalues\n";//visual delimiter of columnNames ans Values
    for(int i = length; i < params.length; i++){
        String value = params[i];
        //do something with values

        ret+=value; //example handling, concatenate everything
    }

    return ret;
}

Avec l'appel:

System.out.println(prepareStatement(5, "a","b","c","d","e","f","g","h","i","j","k"));

Et le même résultat:

abcde
values
fghijk

Il stipule qu'il doit y avoir un seul varlength argument, car si il y a plus, il peut ne pas être en mesure de les distinguer.

Regardons le premier exemple avec une entrée:

String prepareStatement(String... columnNames,String... values)

et de l'appeler avec:

String prepareStatement("foo", "bar", "baz", "foov", "barv", "bazv");

Alors que peut-être il serait logique que les arguments pour être réparti de manière égale, qui ne peut pas être assumée par le compilateur car il ne sait pas de vos intentions d'avoir divisé par le milieu. Afin de sauver lui-même à partir d'un désordre de l'inférence de type et collant bord des cas, il ne permet pas ceci même pour les différents types.

Si vous n'êtes pas très particulier au sujet de l'aide de la chaîne en tant que les paramètres seront plus faciles à prendre HashMap en tant que paramètre. Pas besoin de l'analyse et peut prendre n'importe quel nombre de paramètres.