Vararg Java

Oggi parleremo di qualcosa come varargs in Java. Varargs - o Argomenti variabili - è una tecnologia che consente di creare metodi con un numero arbitrario di argomenti. In questo articolo impareremo come creare tali metodi, discuteremo perché sono necessari i vararg e quando è meglio usarli.

Cosa sono i vararg?

I Vararg sono argomenti di lunghezza variabile: una funzionalità apparsa in JDK5. I Vararg ci permettono di creare metodi con un numero arbitrario di argomenti. In generale, era possibile creare tali metodi prima. È vero, farlo non è stato molto conveniente. Facciamo un esempio. Diciamo che dobbiamo scrivere un metodo che prenda un numero arbitrario di argomenti interi e li sommerà insieme. Abbiamo due opzioni. Opzione 1 - sovraccarico:

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

Ma ci sono due problemi con il sovraccarico. In primo luogo, non è sempre chiaro quando è il momento di fermarsi e, in secondo luogo, è complicato. Gli array sono migliori. Opzione 2 - array:

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

Con un array non è più complicato e l'array sembra non assomigliare a niente... finché non è il momento di chiamare il metodo:

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

Siamo d'accordo, puoi, ovviamente, scrivere tutto più brevemente. Ma in primo luogo, vorrei comunque dimostrare l'inconveniente di utilizzare gli array come argomenti di lunghezza variabile e, in secondo luogo, anche se lo scriviamo in questo modo:

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

Quindi non ci libereremo ancora della quantità eccessiva di codice. Tuttavia, con il rilascio di Java 5, la funzionalità Varargs sembrava risolvere questi problemi. Ha reso possibile passare un numero arbitrario di argomenti ai metodi. Sembra qualcosa del genere:

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

Quindi, riassumiamo. I Vararg sono argomenti di lunghezza variabile, una funzionalità apparsa con il rilascio di Java 5. Successivamente, daremo uno sguardo più approfondito ad alcune regole per lavorare con Vararg.

5 regole di Vararg

Regola 1. L'argomento Vararg (o argomento di lunghezza variabile/arbitraria) è indicato da puntini di sospensione come segue:

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

Regola 2. Un argomento di lunghezza arbitraria può essere specificato solo come argomento in qualche metodo:

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

Regola 3. Ciascun argomento di lunghezza variabile nel corpo del metodo è un array:

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

Regola 4. L'argomento Vararg deve essere l'ultimo nell'elenco degli argomenti del metodo:

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

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

Regola 5: anche se i vararg sono array, quando si chiama un metodo che accetta argomenti di lunghezza variabile, non è necessario creare un array. È sufficiente e anche auspicabile elencare semplicemente gli argomenti richiesti separati da virgole:

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

Esempi di vararg

Nell'esempio seguente, scriveremo un metodo che accetta varargs costituiti da numeri interi e visualizza il numero di elementi passati e la loro somma. Passiamo sia un array che una serie di numeri interi a questo metodo (entrambe le opzioni sono valide):

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

Dopo l'esecuzione il programma restituirà:

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

Vale la pena ricordare che il metodo System.out.printfaccetta anche varargs. Se guardiamo il codice di questo metodo, vedremo questo:

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

Un altro metodo ampiamente utilizzato che accetta varag è String.format. Il suo codice è mostrato di seguito:

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

Quando usare vararg?

La risposta a questa domanda dipende da chi la pone. Se una domanda simile venisse posta da un client di qualche API che dispone di metodi con varargs, la risposta sarebbe "usa tali metodi il più spesso possibile". Per il client di codice, varargs rende la vita molto più semplice rendendo il codice più facile da scrivere e più leggibile. Tuttavia, se questa domanda viene posta da uno sviluppatore API che si chiede quanto spesso dovresti creare metodi con varargs, la risposta sarà "non dovresti usare varargs spesso". Vararg dovrebbe essere utilizzato solo quando il vantaggio del suo utilizzo è evidente. Dovresti anche evitare di sovraccaricare i metodi con vararg, poiché ciò renderà difficile per i client del tuo codice capire quale dei metodi sovraccaricati viene effettivamente chiamato.

Conclusione

Quindi, abbiamo trattato un altro argomento, varargs in Java. Abbiamo capito di cosa si tratta. Abbiamo descritto le regole per l'utilizzo di vararg. Abbiamo esaminato esempi di metodi con argomenti di lunghezza arbitraria e abbiamo anche discusso quando è meglio usare vararg e quando è meglio astenersi dal usarli. Come compito a casa, puoi implementare i seguenti metodi:

• Scrivere voidun metodo che prenda una serie di numeri interi e ne restituisca la media aritmetica.
• Scrivi voidun metodo che prenda una serie di stringhe e stampi la parola più lunga.
• Scrivi un metodo che restituisca booleane accetti una variabile di tipo come primo argomento Stringe una serie booleandi lunghezza variabile come argomento successivo.
  I valori possibili Stringsono AND, OR, XOR. Se il primo argomento ha qualche altro valore, il metodo deve lanciare un'eccezione IllegalArgumentException.
  Il metodo deve eseguire un'operazione logica (specificata nel primo argomento) su ciascun elemento dell'argomento varargs e restituire il risultato del calcolo.

Argomenti di esempio e risultato:

• "AND", vero, vero, falso - restituirà falso
• "OR", falso, vero, falso, falso - restituirà vero