Prima di tutto vorrei chiarire che questa non è una domanda di lingua X rispetto alla lingua Y per determinare quale è meglio.
Utilizzo Java da molto tempo e intendo continuare a utilizzarlo. Parallelamente a questo, attualmente sto imparando Scala con grande interesse: a parte le piccole cose che prendono un po 'd'abitudine alla mia impressione è che posso davvero lavorare molto bene in questa lingua.
La mia domanda è: in che modo il software scritto in Scala si confronta con il software scritto in Java in termini di velocità di esecuzione e consumo di memoria? Ovviamente, questa è una domanda difficile a cui rispondere in generale, ma mi aspetterei che i costrutti di livello superiore come la corrispondenza dei pattern, le funzioni di ordine superiore e così via, introducano alcuni overhead.
Tuttavia, la mia attuale esperienza in Scala è limitata a piccoli esempi con meno di 50 righe di codice e non ho ancora eseguito alcun benchmark fino ad ora. Quindi, non ho dati reali.
Se risulta che Scala ha un sovraccarico su Java, ha senso avere progetti Scala / Java misti, dove si codifica le parti più complesse in Scala e le parti critiche per le prestazioni in Java? È una pratica comune?
EDIT 1
Ho eseguito un piccolo benchmark: creare un elenco di numeri interi, moltiplicare ogni numero intero per due e inserirlo in un nuovo elenco, stampare l'elenco risultante. Ho scritto un'implementazione Java (Java 6) e un'implementazione Scala (Scala 2.9). Ho eseguito entrambi su Eclipse Indigo sotto Ubuntu 10.04.
I risultati sono comparabili: 480 ms per Java e 493 ms per Scala (in media oltre 100 iterazioni). Ecco i frammenti che ho usato.
// Java
public static void main(String[] args)
{
long total = 0;
final int maxCount = 100;
for (int count = 0; count < maxCount; count++)
{
final long t1 = System.currentTimeMillis();
final int max = 20000;
final List<Integer> list = new ArrayList<Integer>();
for (int index = 1; index <= max; index++)
{
list.add(index);
}
final List<Integer> doub = new ArrayList<Integer>();
for (Integer value : list)
{
doub.add(value * 2);
}
for (Integer value : doub)
{
System.out.println(value);
}
final long t2 = System.currentTimeMillis();
System.out.println("Elapsed milliseconds: " + (t2 - t1));
total += t2 - t1;
}
System.out.println("Average milliseconds: " + (total / maxCount));
}
// Scala
def main(args: Array[String])
{
var total: Long = 0
val maxCount = 100
for (i <- 1 to maxCount)
{
val t1 = System.currentTimeMillis()
val list = (1 to 20000) toList
val doub = list map { n: Int => 2 * n }
doub foreach ( println )
val t2 = System.currentTimeMillis()
println("Elapsed milliseconds: " + (t2 - t1))
total = total + (t2 - t1)
}
println("Average milliseconds: " + (total / maxCount))
}
Quindi, in questo caso sembra che il sovraccarico di Scala (usando range, map, lambda) sia veramente minimo, che non è lontano dalle informazioni fornite da Ingegnere mondiale.
Forse ci sono altri costrutti di Scala che dovrebbero essere usati con attenzione perché sono particolarmente pesanti da eseguire?
EDIT 2
Alcuni di voi hanno sottolineato che le stampe nei loop interni occupano la maggior parte di esse il tempo di esecuzione. Li ho rimossi e ho impostato la dimensione degli elenchi su 100000 anziché su 20000. La media risultante era di 88 ms per Java e 49 ms per Scala.