Tout d’abord, je voudrais préciser que ce n’est pas une question langue X-langue-Y qui permet de déterminer laquelle est la meilleure.
J'utilise Java depuis longtemps et j'ai l'intention de continuer à l'utiliser. Parallèlement à cela, j'apprends actuellement Scala avec un grand intérêt: mis à part quelques petites choses qui prennent un certain temps pour s'habituer à mon impression, c'est que je peux vraiment très bien travailler dans cette langue.
Ma question est la suivante: comment les logiciels écrits en Scala se comparent-ils aux logiciels écrits en Java en termes de vitesse d'exécution et de consommation de mémoire? Bien sûr, il est difficile de répondre à cette question en général, mais je m'attendrais à ce que les constructions de niveau supérieur telles que la correspondance de modèle, les fonctions d'ordre supérieur, etc. introduisent une surcharge.
Cependant, mon expérience actuelle à Scala se limite à de petits exemples de moins de 50 lignes de code et je n'ai pas encore effectué de tests de performances. Donc, je n'ai pas de données réelles.
S’il s’avère que Scala a une surcharge en Java, est-il judicieux d’avoir des projets Scala / Java mixtes, dans lesquels on code les parties les plus complexes de Scala et les parties critiques en termes de performance en Java? Est-ce une pratique courante?
EDIT 1
J'ai exécuté un petit test d'évaluation: créez une liste d'entiers, multipliez chaque entier par deux et mettez-la dans une nouvelle liste, imprimez la liste résultante. J'ai écrit une implémentation Java (Java 6) et une implémentation Scala (Scala 2.9). J'ai couru les deux sur Eclipse Indigo sous Ubuntu 10.04.
Les résultats sont comparables: 480 ms pour Java et 493 ms pour Scala (moyenne sur 100 itérations). Voici les extraits que j'ai utilisés.
// 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))
}Ainsi, dans ce cas, il semble que les frais généraux de Scala (utilisant range, map, lambda) soient vraiment minimes, ce qui n’est pas loin des informations fournies par World Engineer.
Peut-être y a-t-il d'autres constructions Scala qui devraient être utilisées avec précaution car elles sont particulièrement lourdes à exécuter?
EDIT 2
Certains d'entre vous ont fait remarquer que les impressions dans les boucles internes occupent la majeure partie du temps d'exécution. Je les ai supprimés et ai défini la taille des listes sur 100000 au lieu de 20000. La moyenne résultante était de 88 ms pour Java et de 49 ms pour Scala.