Prima di tutto vorrei chiarire che questa non è una domanda lingua-X-contro-lingua-Y per determinare quale sia la migliore.
Uso Java da molto tempo e intendo continuare ad usarlo. Parallelamente a questo, sto attualmente imparando Scala con grande interesse: a parte le cose minori che richiedono un po 'di tempo per abituarsi alla mia impressione è che posso davvero lavorare molto bene in questa lingua.
La mia domanda è: come si confronta il software scritto in Scala con il software scritto in Java in termini di velocità di esecuzione e consumo di memoria? Naturalmente, questa è una domanda difficile a cui rispondere in generale, ma mi aspetterei che costrutti di livello superiore come la corrispondenza dei modelli, le funzioni di ordine superiore, ecc., Introducano alcune spese generali.
Tuttavia, la mia attuale esperienza in Scala è limitata a piccoli esempi con 50 righe di codice e finora non ho eseguito alcun benchmark. Quindi, non ho dati reali.
Se si è scoperto che Scala ha un sovraccarico di Java, ha senso avere progetti Scala / Java misti, in cui si codificano le parti più complesse in Scala e le parti critiche per le prestazioni in Java? È una pratica comune?
MODIFICA 1
Ho eseguito un piccolo benchmark: crea un elenco di numeri interi, moltiplica ogni numero intero per due e lo inserisce in un nuovo elenco, stampa l'elenco risultante. Ho scritto un'implementazione Java (Java 6) e un'implementazione Scala (Scala 2.9). Ho eseguito entrambi su Eclipse Indigo con Ubuntu 10.04.
I risultati sono comparabili: 480 ms per Java e 493 ms per Scala (media di 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 davvero minimo, che non è lontano dalle informazioni fornite dall'ingegnere mondiale.
Forse ci sono altri costrutti Scala che dovrebbero essere usati con cura perché sono particolarmente pesanti da eseguire?
MODIFICA 2
Alcuni di voi hanno sottolineato che le stampe negli anelli interni occupano la maggior parte del tempo di esecuzione. Li ho rimossi e ho impostato la dimensione degli elenchi su 100000 anziché su 20000. La media risultante era 88 ms per Java e 49 ms per Scala.