Varargs Java

Aujourd'hui, nous allons discuter de choses telles que les varargs en Java. Varargs - ou Variable Arguments - est une technologie qui permet de créer des méthodes avec un nombre arbitraire d'arguments. Dans cet article, nous apprendrons comment créer de telles méthodes, expliquerons pourquoi les varargs sont nécessaires et quand il est préférable de les utiliser.

Que sont les varargs ?

Les Varargs sont des arguments de longueur variable : une fonctionnalité apparue dans le JDK5. Les Varargs nous permettent de créer des méthodes avec un nombre arbitraire d'arguments. Dans l’ensemble, il était possible de créer de telles méthodes auparavant. C'est vrai que faire cela n'était pas très pratique. Donnons un exemple. Disons que nous devons écrire une méthode qui prendra un nombre arbitraire d'arguments entiers et les additionnera. Nous avons deux options. Option 1 - surcharge :

class Calculator {
    int sum(int a, int b){...};
    int sum(int a, int b, int c){...};
    int sum(int a, int b, int c, int d){...};
    int sum(int a, int b, int c, int d, int e){...};
}

Mais la surcharge pose deux problèmes. Premièrement, il n’est pas toujours clair quand il est temps de s’arrêter, et deuxièmement, c’est fastidieux. Les tableaux sont meilleurs. Option 2 - tableaux :

class Calculator {
    int sum(int[] numbers){...};
}

Avec un tableau, ce n'est plus encombrant, et le tableau ne ressemble à rien... jusqu'à ce qu'il soit temps d'appeler la méthode :

public static void main(String... sss) {
    Calculator calculator = new Calculator();

    int[] arguments = new int[7];
    arguments[0] = 1;
    arguments[1] = 10;
    arguments[2] = 123;
    arguments[3] = 234;
    arguments[4] = 6234;
    arguments[5] = 12;
    arguments[6] = 8;

    int sum = calculator.sum(arguments);
}

Nous sommes d'accord, vous pouvez bien sûr tout écrire plus brièvement. Mais d'une part, je voudrais quand même démontrer l'inconvénient d'utiliser des tableaux comme arguments de longueur variable, et d'autre part, même si nous l'écrivons comme ceci :

int[] arguments = {1,10,123,234,6234,12,8};
int sum = calculator.sum(arguments);

Ensuite, nous ne nous débarrasserons toujours pas de la quantité excessive de code. Cependant, avec la sortie de Java 5, la fonctionnalité Varargs semble résoudre ces problèmes. Cela permettait de passer un nombre arbitraire d'arguments aux méthodes. Cela ressemble à ceci :

public class Calculator {
    public static void main(String... sss) {
        Calculator calculator = new Calculator();
        int sum = calculator.sum(1,10,123,234,6234,12,8);
    }
    int sum(int... numbers){
       return Arrays.stream(numbers).sum();
    }
}

Alors, résumons. Les Varargs sont des arguments de longueur variable, une fonctionnalité apparue avec la sortie de Java 5. Nous examinerons ensuite de plus près certaines règles permettant de travailler avec les Varargs.

5 règles des varargs

Règle 1. L'argument Vararg (ou argument de longueur variable/arbitraire) est indiqué par des points de suspension comme suit :

String... words
Integer... numbers
Person... people
Cat... cats

Règle 2. Un argument de longueur arbitraire ne peut être spécifié que comme argument d'une méthode :

void print(String... words)
int sum(Integer... numbers)
void save(Person... people)
void feed(Cat... cats)

Règle 3. Chacun de ces arguments de longueur variable dans le corps de la méthode est un tableau :

void print(String... words){
    for (int i = 0; i < words.length; i++) {
        System.out.println(words[i]);
    }
}

Règle 4. L'argument Vararg doit être le dernier de la liste des arguments de la méthode :

void print(String... words, String anotherWord) // - Так нельзя!
void print(String... words, int someNumber) // - Так нельзя!

void print(String anotherWord, String... words) // - Так можно
void print(int someNumber, String... words) // - Так можно

Règle 5 : Même si les varargs sont des tableaux, lors de l'appel d'une méthode qui prend des arguments de longueur variable, il n'est pas nécessaire de créer un tableau. Il est suffisant et même souhaitable de simplement lister les arguments requis séparés par des virgules :

public class Main {
    public static void main(String... sss) {
        print("How","же","прекрасно","изучать","Java");
    }

    static void print(String... words){
        for (int i = 0; i < words.length; i++) {
            System.out.println(words[i]);
        }
    }
}

Exemples de varargs

Dans l'exemple ci-dessous, nous allons écrire une méthode qui prend des varargs constitués d'entiers et affiche le nombre d'éléments passés et leur somme. Passons à la fois un tableau et une série d'entiers à cette méthode (les deux options sont valides) :

public static void main(String... sss) {
    int[] a = new int[100];
    for (int i = 0; i < a.length; i++) {
        a[i] = i;
    }

    sum(a);
    sum(1,2,3,4,5,6,7,8,9,10);
}

static void sum(int... numbers){
    final int length = numbers.length;
    final int sum = Arrays.stream(numbers).sum();
    final String lineSeparator = System.lineSeparator();

    System.out.printf("Кол-во элементов для сложения - %d, сумма - %d%s", length, sum, lineSeparator);
}

Après exécution, le programme affichera :

Кол-во элементов для сложения - 100, сумма - 4950 
Кол-во элементов для сложения - 10, сумма - 55 

Il convient de mentionner que la méthode System.out.printfaccepte également les varargs. Si nous regardons le code de cette méthode, nous verrons ceci :

public PrintStream printf(String format, Object ... args) {
    return format(format, args);
}

Une autre méthode largement utilisée qui accepte les varags est String.format. Son code est indiqué ci-dessous :

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

Quand utiliser les varargs ?

La réponse à cette question dépend de qui la pose. Si une question similaire est posée par un client d'une API dotée de méthodes avec varargs, la réponse serait alors "utiliser ces méthodes aussi souvent que possible". Pour le client code, varargs rend la vie beaucoup plus facile en rendant le code plus facile à écrire et plus lisible. Cependant, si cette question est posée par un développeur d'API qui se demande à quelle fréquence vous devez créer des méthodes avec des varargs, alors la réponse sera « vous ne devriez pas utiliser souvent des varargs ». Varargs ne doit être utilisé que lorsque l’avantage de son utilisation est évident. Vous devez également éviter de surcharger les méthodes avec des varargs, car cela empêchera les clients de votre code de comprendre laquelle des méthodes surchargées est réellement appelée.

Conclusion

Nous avons donc abordé un autre sujet, les varargs en Java. Nous avons compris ce que c'était. Nous avons décrit les règles d'utilisation des varargs. Nous avons examiné des exemples de méthodes avec des arguments de longueur arbitraire, et avons également discuté du moment où il est préférable d'utiliser des varargs et du moment où il est préférable de s'abstenir de les utiliser. Comme devoir, vous pouvez mettre en œuvre les méthodes suivantes :

• Écrivez voidune méthode qui prend une série d'entiers et renvoie leur moyenne arithmétique.
• Écrivez voidune méthode qui prend une série de chaînes et imprime le mot le plus long.
• Écrivez une méthode qui renvoie booleanet prend une variable de type comme premier argument Stringet une série booleande longueur variable comme argument suivant.
  Les valeurs possibles Stringsont AND, OR, XOR. Si le premier argument a une autre valeur, la méthode doit lever une exception IllegalArgumentException.
  La méthode doit effectuer une opération logique (spécifiée dans le premier argument) sur chaque élément de l'argument varargs et renvoyer le résultat du calcul.

Exemples d'arguments et de résultat :

• "ET", vrai, vrai, faux - renverra faux
• "OR", faux, vrai, faux, faux - renverra vrai