Java varargs

Ngayon ay tatalakayin natin ang isang bagay tulad ng varargs sa Java. Ang Varargs - o Variable Argument - ay isang teknolohiyang nagbibigay-daan sa iyong lumikha ng mga pamamaraan na may arbitrary na bilang ng mga argumento. Sa artikulong ito, matututunan natin kung paano lumikha ng mga ganitong pamamaraan, talakayin kung bakit kailangan ang mga varargs at kung kailan pinakamahusay na gamitin ang mga ito.

Ano ang varargs?

Ang mga Vararg ay mga argumento na may variable na haba: isang tampok na lumitaw sa JDK5. Pinapayagan kami ng Varargs na lumikha ng mga pamamaraan na may arbitrary na bilang ng mga argumento. Sa pangkalahatan, posible na lumikha ng gayong mga pamamaraan dati. Totoo, ang paggawa nito ay hindi masyadong maginhawa. Magbigay tayo ng halimbawa. Sabihin nating kailangan nating magsulat ng isang paraan na kukuha ng di-makatwirang bilang ng mga integer na argumento at pagsasama-samahin ang mga ito. Mayroon kaming dalawang pagpipilian. Opsyon 1 - labis na karga:

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

Ngunit may dalawang problema sa labis na karga. Una, ito ay hindi palaging malinaw kung oras na upang huminto, at pangalawa, ito ay masalimuot. Ang mga array ay mas mahusay. Opsyon 2 - mga array:

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

Sa isang array, hindi na ito masalimuot, at ang array ay parang wala lang... hanggang sa oras na para tawagan ang pamamaraan:

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

Sumasang-ayon kami, maaari mong, siyempre, isulat ang lahat nang mas maikli. Ngunit una, gusto ko pa ring ipakita ang abala ng paggamit ng mga arrays bilang variable-length na mga argumento, at pangalawa, kahit na isulat natin ito ng ganito:

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

Pagkatapos ay hindi pa rin namin aalisin ang sobrang dami ng code. Gayunpaman, sa paglabas ng Java 5, lumitaw ang tampok na Varargs upang malutas ang mga problemang ito. Ginawa nitong posible na ipasa ang isang arbitrary na bilang ng mga argumento sa mga pamamaraan. Mukhang ganito:

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

Kaya, sabihin summarize. Ang mga Varargs ay variable-length na mga argumento, isang tampok na lumitaw sa paglabas ng Java 5. Susunod, titingnan natin ang ilang mga panuntunan para sa pagtatrabaho sa Varargs.

5 panuntunan ng varargs

Panuntunan 1. Ang argumento ng Vararg (o argumento ng variable/arbitrary na haba) ay ipinapahiwatig ng isang ellipsis tulad ng sumusunod:

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

Panuntunan 2. Ang isang argument na may di-makatwirang haba ay maaari lamang tukuyin bilang isang argumento sa ilang pamamaraan:

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

Panuntunan 3. Ang bawat naturang variable-length na argumento sa katawan ng pamamaraan ay isang array:

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

Panuntunan 4. Ang argumento ng Vararg ay dapat ang huli sa listahan ng argumento ng pamamaraan:

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

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

Panuntunan 5: Kahit na ang mga varargs ay mga array, kapag tumatawag ng isang paraan na tumatagal ng mga variable na haba ng argumento, hindi kinakailangang gumawa ng array. Ito ay sapat at kahit na kanais-nais na ilista lamang ang mga kinakailangang argumento na pinaghihiwalay ng mga kuwit:

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

Mga halimbawa ng varargs

Sa halimbawa sa ibaba, magsusulat kami ng isang paraan na kumukuha ng mga vararg na binubuo ng mga integer at ipinapakita ang bilang ng mga elementong naipasa at ang kanilang kabuuan. Ipasa natin ang parehong array at isang serye ng mga integer sa paraang ito (ang parehong mga opsyon ay wasto):

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

Pagkatapos patakbuhin ang programa ay maglalabas ng:

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

Ito ay nagkakahalaga ng pagbanggit na ang pamamaraan ay System.out.printftumatanggap din ng mga varargs. Kung titingnan natin ang code ng pamamaraang ito, makikita natin ito:

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

Ang isa pang malawakang ginagamit na paraan na tumatanggap ng mga varag ay String.format. Ang code nito ay ipinapakita sa ibaba:

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

Kailan gagamitin ang varargs?

Ang sagot sa tanong na ito ay depende sa kung sino ang nagtatanong. Kung ang isang katulad na tanong ay tatanungin ng isang kliyente ng ilang API na may mga pamamaraan na may mga varargs, ang sagot ay "gumamit ng mga ganitong pamamaraan nang madalas hangga't maaari." Para sa code client, pinadali ng varargs ang buhay sa pamamagitan ng paggawa ng code na mas madaling isulat at mas nababasa. Gayunpaman, kung ang tanong na ito ay tatanungin ng isang developer ng API na nag-iisip kung gaano kadalas ka dapat gumawa ng mga pamamaraan na may mga varargs, ang magiging sagot ay "hindi ka dapat gumamit ng mga varargs nang madalas." Dapat lang gamitin ang Varargs kapag kitang-kita ang benepisyo ng paggamit nito. Dapat mo ring iwasan ang mga overloading na pamamaraan sa mga varargs, dahil ito ay magpapahirap sa mga kliyente ng iyong code na maunawaan kung alin sa mga overloaded na pamamaraan ang aktwal na tinatawag.

Konklusyon

Kaya, nasaklaw namin ang isa pang paksa, varargs sa Java. Nalaman namin kung ano ito. Inilarawan namin ang mga patakaran para sa paggamit ng varargs. Tinitingnan namin ang mga halimbawa ng mga pamamaraan na may mga argumento ng di-makatwirang haba, at tinalakay din kung kailan mas mahusay na gumamit ng mga varargs at kung kailan mas mahusay na pigilin ang paggamit ng mga ito. Bilang araling-bahay, maaari mong ipatupad ang mga sumusunod na pamamaraan:

• Sumulat voidng isang paraan na kumukuha ng isang serye ng mga integer at ibinabalik ang kanilang arithmetic mean.
• Sumulat voidng isang paraan na tumatagal ng isang serye ng mga string at nagpi-print ng pinakamahabang salita.
• Sumulat ng isang paraan na nagbabalik booleanat kumukuha ng variable na uri bilang unang argumento String, at isang serye booleanng variable na haba bilang susunod na argumento.
  Ang mga posibleng halaga Stringay AND, OR, XOR. Kung ang unang argumento ay may ilang iba pang halaga, ang pamamaraan ay dapat magtapon ng isang pagbubukod IllegalArgumentException.
  Ang pamamaraan ay dapat magsagawa ng isang lohikal na operasyon (tinukoy sa unang argumento) sa bawat elemento ng varargs argument at ibalik ang resulta ng pagkalkula.

Mga halimbawang argumento at resulta:

• "AT", totoo, totoo, mali - ay magbabalik ng mali
• "O", mali, totoo, mali, mali - ay magbabalik ng totoo