Java-Varargs

Heute werden wir so etwas wie Varargs in Java besprechen. Varargs – oder Variable Arguments – ist eine Technologie, die es Ihnen ermöglicht, Methoden mit einer beliebigen Anzahl von Argumenten zu erstellen. In diesem Artikel lernen wir, wie man solche Methoden erstellt, diskutieren, warum Varargs benötigt werden und wann es besser ist, sie zu verwenden.

Was sind Varargs?

Varargs sind Argumente variabler Länge: eine Funktion, die in JDK5 eingeführt wurde. Mit Varargs können wir Methoden mit einer beliebigen Anzahl von Argumenten erstellen. Im Großen und Ganzen war es schon früher möglich, solche Methoden zu erstellen. Es stimmt, das war nicht sehr praktisch. Geben wir ein Beispiel. Nehmen wir an, wir müssen eine Methode schreiben, die eine beliebige Anzahl ganzzahliger Argumente annimmt und diese addiert. Wir haben zwei Möglichkeiten. Option 1 – Überlastung:

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

Es gibt jedoch zwei Probleme mit der Überlastung. Erstens ist es nicht immer klar, wann es Zeit ist aufzuhören, und zweitens ist es umständlich. Arrays sind besser. Option 2 – Arrays:

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

Mit einem Array ist es nicht mehr umständlich und das Array scheint wie nichts auszusehen ... bis es Zeit ist, die Methode aufzurufen:

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

Wir sind uns einig, Sie können natürlich alles auch kürzer aufschreiben. Aber erstens möchte ich trotzdem die Unbequemlichkeit der Verwendung von Arrays als Argumente variabler Länge demonstrieren, und zweitens, selbst wenn wir es so schreiben:

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

Dann werden wir die übermäßige Menge an Code immer noch nicht los. Mit der Veröffentlichung von Java 5 schien die Varargs-Funktion diese Probleme jedoch zu lösen. Dadurch war es möglich, eine beliebige Anzahl von Argumenten an Methoden zu übergeben. Es sieht ungefähr so ​​aus:

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

Fassen wir also zusammen. Varargs sind Argumente variabler Länge, eine Funktion, die mit der Veröffentlichung von Java 5 eingeführt wurde. Als Nächstes werden wir uns einige Regeln für die Arbeit mit Varargs genauer ansehen.

5 Vararg-Regeln

Regel 1. Das Vararg-Argument (oder das Argument variabler/beliebiger Länge) wird durch Auslassungspunkte wie folgt angezeigt:

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

Regel 2. Ein Argument beliebiger Länge kann nur als Argument für eine Methode angegeben werden:

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

Regel 3. Jedes dieser Argumente variabler Länge im Methodenkörper ist ein Array:

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

Regel 4. Das Vararg-Argument muss das letzte in der Methodenargumentliste sein:

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

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

Regel 5: Auch wenn Varargs Arrays sind, ist es beim Aufrufen einer Methode, die Argumente variabler Länge akzeptiert, nicht erforderlich, ein Array zu erstellen. Es reicht aus und ist sogar wünschenswert, die erforderlichen Argumente einfach durch Kommas getrennt aufzulisten:

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

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

Beispiele für Varargs

Im folgenden Beispiel schreiben wir eine Methode, die aus Ganzzahlen bestehende Varargs akzeptiert und die Anzahl der übergebenen Elemente sowie deren Summe anzeigt. Übergeben wir dieser Methode sowohl ein Array als auch eine Reihe von Ganzzahlen (beide Optionen sind gültig):

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

Nach dem Ausführen gibt das Programm Folgendes aus:

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

Es ist erwähnenswert, dass die Methode System.out.printfauch Varargs akzeptiert. Wenn wir uns den Code dieser Methode ansehen, sehen wir Folgendes:

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

Eine weitere weit verbreitete Methode, die Varags akzeptiert, ist String.format. Der Code ist unten dargestellt:

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

Wann sollte man Varargs verwenden?

Die Antwort auf diese Frage hängt davon ab, wer fragt. Wenn ein Client einer API, die über Methoden mit Varargs verfügt, eine ähnliche Frage stellt, lautet die Antwort: „Verwenden Sie solche Methoden so oft wie möglich.“ Für den Code-Client macht Varargs das Leben viel einfacher, indem es Code einfacher zu schreiben und besser lesbar macht. Wenn diese Frage jedoch von einem API-Entwickler gestellt wird, der sich fragt, wie oft Sie Methoden mit Varargs erstellen sollten, lautet die Antwort: „Sie sollten Varargs nicht oft verwenden.“ Varargs sollten nur verwendet werden, wenn der Nutzen ihrer Verwendung offensichtlich ist. Sie sollten außerdem vermeiden, Methoden mit Varargs zu überladen, da dies es für Clients Ihres Codes schwierig macht, zu verstehen, welche der überladenen Methoden tatsächlich aufgerufen wird.

Abschluss

Daher haben wir ein anderes Thema behandelt: Varargs in Java. Wir haben herausgefunden, was es ist. Wir haben die Regeln für die Verwendung von Varargs beschrieben. Wir haben uns Beispiele für Methoden mit Argumenten beliebiger Länge angesehen und auch besprochen, wann es besser ist, Varargs zu verwenden und wann es besser ist, darauf zu verzichten. Als Hausaufgabe können Sie folgende Methoden umsetzen:

• Schreiben Sie voideine Methode, die eine Reihe von ganzen Zahlen verwendet und deren arithmetisches Mittel zurückgibt.
• Schreiben Sie voideine Methode, die eine Reihe von Zeichenfolgen verwendet und das längste Wort ausgibt.
• Schreiben Sie eine Methode, die booleaneine Variable vom Typ zurückgibt und als erstes Argument Stringund eine Reihe booleanvariabler Länge als nächstes Argument verwendet.
  Mögliche Werte Stringsind AND, OR, XOR. Wenn das erste Argument einen anderen Wert hat, muss die Methode eine Ausnahme auslösen IllegalArgumentException.
  Die Methode muss eine logische Operation (angegeben im ersten Argument) für jedes Element des varargs-Arguments ausführen und das Ergebnis der Berechnung zurückgeben.

Beispielargumente und Ergebnis:

• „UND“, wahr, wahr, falsch – gibt „falsch“ zurück
• „OR“, false, true, false, false – gibt true zurück