String [] args vs (String... Args)

Durante la programmazione per Android, ogni volta che utilizzo un AsyncTask il metodo doInBackground è simile al seguente.

 protected String doInBackground(String... args)

Ma quando uso gli argomenti ovunque in quel blocco, posso accedervi come un normale array di stringhe, ad esempio nel mio programma

        @Override
    protected String doInBackground(String... args)
    {
        String details = "";
        try
        {
            details = facade.getRecipeDetails(args[0]);
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        return details;
    }

Il che funziona bene e non ho problemi a gestirlo. Ma mi chiedo perché usano (String ... args) invece di un normale array di stringhe. È solo perché nel metodo di chiamata puoi semplicemente scrivere qualcosa del tipo:

 new AsyncHandler.execute("argument1","argument2","argument3",...)

invece di creare un nuovo array per passare gli argomenti? Anche se potremmo scrivere

new AsyncHandler().execute(new String[]{"Argument1","Argument2"});

che è un po 'più dettagliato.

(String ...) e String [] sono sinonimi di come funzionano, ma il passaggio degli argomenti è semplicemente più semplice usando il primo perché non è necessario creare un array? Per quanto ne so, il primo viene anche tradotto in una matrice di stringhe in background, quindi si comporterebbero entrambi nello stesso codice ed è solo "zucchero sintattico"?

java android

— Dylan Meeus
fonte

(String ...)significa che puoi aggiungere tutti i Stringparametri che vuoi, String[]è un parametro che è un array di stringhe. (String ...)dipende dal primo parametro di AsyncTask, non è sempre String.

— FaizanRabbani,

@FaizanRabbani tranne che puoi anche chiamare un String...come se fosseString[]

— maniaco del cricchetto

@ratchetfreak Sì, può agire come un String[], ma supponiamo che sia stato di default String[]. Sarebbe stato un bel problema usare Stringparametri diversi in un array. Invece hanno dato una flessibilità da usare (String ...).

— FaizanRabbani,

@FaizanRabbani Sono consapevole che non è sempre String, è solo un esempio =). Lo stesso vale per Boolean ... o altre cose, ma mi è piaciuto usare String a causa dei main (String [] args) con cui abbiamo familiarità. E hai detto 'puoi passare tutte le stringhe che vuoi', beh puoi passare un bel po 'di stringhe con un array. Per me sembra ancora che tu possa ottenere lo stesso risultato con gli array, anche se è meno leggibile e più una seccatura. (Il passaggio di una matrice di array, ad esempio, ridurrebbe un po 'la leggibilità). È corretto quindi che sia principalmente leggibile? (grazie già a proposito)

— Dylan Meeus,

@FaizanRabbani bene è un semplice giro di new String[]{...}conversione (è quello che succede effettivamente quando si usa un String...)

— maniaco del cricchetto

(String ...)è una matrice di parametri di tipo String, dove come String[]è un singolo parametro .

Ora qui String[]può riempire completamente lo stesso scopo qui ma (String ...)fornisce più leggibilità e facilità d'uso.

Fornisce anche un'opzione che possiamo utilizzare più array Stringanziché uno singolo usando String[].

— FaizanRabbani
fonte

Mentre String[]può essere passato in un metodo prendendo String...come parametro, due String[]s non possono. Non esiste una concatenazione di array implicita che ha luogo qui.

Una caratteristica di String [] vs String ... è che "String ..." non deve far parte della chiamata.

public void test(String... args){ 
   if(args.length > 0){
      for( String text : args){
         System.out.println(text);
      }
   }else{
      System.out.println("No args defined.");
   }
}

public void callerTest(){
     test();
     System.out.println();

     test("tree");
     System.out.println();

     test("dog", "cat", "pigeon");
}

Quindi se chiamate callerTest();l'output sarà:

No args defined.

tree

dog
cat
pigeon

— GetBackerZ
fonte