In che modo Scala può ricevere più parametri in una definizione di metodo?

Question

Java ha:

public void someMethod(int ... intArray) { // question: what is the equivalent to "..." 
    // do something with intArray 
} 

come posso ottenere la stessa funzionalità a Scala? Cioè, passando un numero indefinito di parametri a un metodo?

Answer 1

def someMethod(values : Int*) 

Fornisce un array. Metti il ​​parametro argomento variabile come l'ultimo parametro formale.

Answer 2

Sia Java che Scala hanno vararg e supportano entrambi solo gli ultimi parametri.

def varargTest(ints:Int*) { ints.foreach(println) } 

Da this article, la differenza è nel tipo utilizzato per gli argomenti varargs:

• array per Java
• Seq (sequenza) per Scala: può essere iterato e molti metodi come collezioni foreach, map, filter, find, ... sono disponibili

Il '*' sta per 0 o più argomenti.

Nota: se i valori dei parametri sono già "confezionati" come sequenza, ad esempio un elenco, fallisce:

# varargTest(List(1,2,3,4,5)) 
# //--> error: type mismatch; 
# //--> found : List[Int] 
# //--> required: Int 
# //-->  varargTest(List(1,2,3,4,5)) 
# //--> 

Ma questo passerà:

varargTest(List(1,2,3):_*) 
    //--> 1 
    //--> 2 
    //--> 3 

'_' è una scorciatoia segnaposto per inferenza di tipo. '_*' è qui applicato a un 'tipo ripetuto.
sezione 4.6.2 di Scala Specification menziona:

L'ultimo valore medio di una sezione parametro può essere suffisso “*”, ad esempio (..., x:T *).
Il tipo di tale parametro ripetuto all'interno del metodo è quindi il tipo di sequenza scala.Seq[T].
I metodi con parametri ripetuti T* accettano un numero variabile di argomenti di tipo T.

(T1, . . . , Tn,S*)U => (T1, . . . , Tn,S, . . . , S)U, 

L'unica eccezione a questa regola è se l'ultimo argomento è contrassegnato per essere un argomento sequenza tramite una _* tipo di annotazione.

(e1, . . . , en,e0: _*) => (T1, . . . , Tn, scala.Seq[S]). 

Note bis: Attenzione al tipo cancellazione sottostante di Java:

//--> error: double definition: 
//--> method varargTest:(ints: Seq[Int])Unit and 
//--> method varargTest:(ints: Int*)Unit at line 10 
//--> have same type after erasure: (ints: Sequence)Unit 
//--> def varargTest(ints:Seq[Int]) { varargTest(ints: _*) }