Java varargs

Hari ini kita akan membincangkan perkara seperti varargs di Jawa. Varargs - atau Argumen Pembolehubah - ialah teknologi yang membolehkan anda mencipta kaedah dengan bilangan argumen yang sewenang-wenangnya. Dalam artikel ini, kita akan belajar cara mencipta kaedah sedemikian, membincangkan mengapa varargs diperlukan dan bila terbaik untuk menggunakannya.

Apakah varargs?

Varargs ialah argumen panjang boleh ubah: ciri yang muncul dalam JDK5. Varargs membenarkan kami mencipta kaedah dengan bilangan hujah yang sewenang-wenangnya. Pada umumnya, kaedah sedemikian boleh dibuat sebelum ini. Benar, melakukan ini tidak begitu mudah. Mari kita beri contoh. Katakan kita perlu menulis kaedah yang akan mengambil nombor arbitrari hujah integer dan menambahnya bersama-sama. Kami ada dua pilihan. Pilihan 1 - beban berlebihan:

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

Tetapi terdapat dua masalah dengan lebihan muatan. Pertama, ia tidak selalu jelas bila masa untuk berhenti, dan kedua, ia menyusahkan. Tatasusunan adalah lebih baik. Pilihan 2 - tatasusunan:

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

Dengan tatasusunan ia tidak lagi menyusahkan, dan tatasusunan itu kelihatan seperti tiada apa-apa... sehingga tiba masanya untuk memanggil kaedah:

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

Kami bersetuju, anda boleh, sudah tentu, menulis segala-galanya dengan lebih ringkas. Tetapi pertama, saya masih ingin menunjukkan kesulitan menggunakan tatasusunan sebagai argumen panjang berubah-ubah, dan kedua, walaupun kita menulisnya seperti ini:

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

Kemudian kami masih tidak akan menyingkirkan jumlah kod yang berlebihan. Walau bagaimanapun, dengan keluaran Java 5, ciri Varargs muncul untuk menyelesaikan masalah ini. Ia memungkinkan untuk menghantar bilangan hujah yang sewenang-wenangnya kepada kaedah. Ia kelihatan seperti ini:

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

Jadi, mari kita ringkaskan. Varargs ialah hujah pembolehubah panjang, ciri yang muncul dengan keluaran Java 5. Seterusnya, kita akan melihat dengan lebih dekat beberapa peraturan untuk bekerja dengan Varargs.

5 peraturan varargs

Peraturan 1. Argumen Vararg (atau argumen panjang pembolehubah/arbitrari) ditunjukkan oleh elipsis seperti berikut:

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

Peraturan 2. Hujah dengan panjang sewenang-wenangnya hanya boleh ditentukan sebagai hujah kepada beberapa kaedah:

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

Peraturan 3. Setiap hujah pembolehubah panjang dalam badan kaedah ialah tatasusunan:

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

Peraturan 4. Argumen Vararg mestilah yang terakhir dalam senarai argumen kaedah:

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

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

Peraturan 5: Walaupun varargs ialah tatasusunan, apabila memanggil kaedah yang mengambil argumen panjang pembolehubah, ia tidak perlu mencipta tatasusunan. Adalah mencukupi dan wajar untuk hanya menyenaraikan argumen yang diperlukan yang dipisahkan dengan koma:

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

Contoh varargs

Dalam contoh di bawah, kami akan menulis kaedah yang mengambil vararg yang terdiri daripada integer dan memaparkan bilangan elemen yang diluluskan dan jumlahnya. Mari kita lulus tatasusunan dan satu siri integer kepada kaedah ini (kedua-dua pilihan adalah sah):

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

Selepas menjalankan program akan mengeluarkan:

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

Perlu dinyatakan bahawa kaedah itu System.out.printfjuga menerima varargs. Jika kita melihat kod kaedah ini, kita akan melihat ini:

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

Kaedah lain yang digunakan secara meluas yang menerima varags ialah String.format. Kodnya ditunjukkan di bawah:

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

Bila hendak menggunakan varargs?

Jawapan kepada soalan ini bergantung kepada siapa yang bertanya. Jika soalan serupa ditanya oleh pelanggan beberapa API yang mempunyai kaedah dengan varargs, maka jawapannya ialah "gunakan kaedah sedemikian sekerap mungkin." Untuk klien kod, varargs menjadikan hidup lebih mudah dengan menjadikan kod lebih mudah untuk ditulis dan lebih mudah dibaca. Walau bagaimanapun, jika soalan ini ditanya oleh pembangun API yang tertanya-tanya berapa kerap anda perlu membuat kaedah dengan varargs, maka jawapannya ialah "anda tidak boleh menggunakan varargs selalu." Varargs hanya boleh digunakan apabila manfaat penggunaannya jelas. Anda juga harus mengelakkan kaedah terlebih muatan dengan varargs, kerana ini akan menyukarkan pelanggan kod anda untuk memahami kaedah yang terlebih muatan sebenarnya dipanggil.

Kesimpulan

Jadi, kami telah membincangkan topik lain, varargs dalam Java. Kami tahu apa itu. Kami menerangkan peraturan untuk menggunakan varargs. Kami melihat contoh kaedah dengan hujah panjang sewenang-wenangnya, dan juga membincangkan bila lebih baik menggunakan varargs dan bila lebih baik untuk menahan diri daripada menggunakannya. Sebagai kerja rumah, anda boleh melaksanakan kaedah berikut:

• Tulis voidkaedah yang mengambil satu siri integer dan mengembalikan min aritmetiknya.
• Tulis voidkaedah yang mengambil satu siri rentetan dan mencetak perkataan terpanjang.
• Tulis kaedah yang mengembalikan booleandan mengambil pembolehubah jenis sebagai argumen pertama Stringdan satu siri booleanpanjang pembolehubah sebagai argumen seterusnya.
  Nilai yang mungkin Stringadalah AND, OR, XOR. Jika hujah pertama mempunyai beberapa nilai lain, kaedah mesti membuang pengecualian IllegalArgumentException.
  Kaedah mesti melakukan operasi logik (dinyatakan dalam argumen pertama) pada setiap elemen argumen varargs dan mengembalikan hasil pengiraan.

Contoh hujah dan keputusan:

• "DAN", benar, benar, salah - akan kembali palsu
• "ATAU", palsu, benar, salah, palsu - akan kembali benar