सबसे पहले मैं यह स्पष्ट करना चाहूंगा कि यह भाषा-एक्स-बनाम-भाषा-वाई प्रश्न नहीं है जो यह निर्धारित करने के लिए बेहतर है।
मैं लंबे समय से जावा का उपयोग कर रहा हूं और मैं इसका उपयोग करने का इरादा रखता हूं। इसके समानांतर, मैं वर्तमान में स्काला को बहुत रुचि के साथ सीख रहा हूं: मामूली चीजों के अलावा जो कुछ मेरी आदत के लिए उपयोग हो रहा है वह यह है कि मैं वास्तव में इस भाषा में बहुत अच्छा काम कर सकता हूं।
मेरा सवाल है: स्कैला में लिखे गए सॉफ्टवेयर निष्पादन गति और मेमोरी खपत के मामले में जावा में लिखे गए सॉफ़्टवेयर की तुलना कैसे करते हैं? बेशक, यह सामान्य रूप से जवाब देने के लिए एक कठिन सवाल है, लेकिन मैं उम्मीद करूंगा कि उच्च स्तर के निर्माण जैसे कि पैटर्न मिलान, उच्च-क्रम फ़ंक्शन आदि, कुछ ओवरहेड का परिचय देंगे।
हालांकि, स्काला में मेरा वर्तमान अनुभव कोड की 50 लाइनों के तहत छोटे उदाहरणों तक सीमित है और मैंने अब तक कोई भी बेंचमार्क नहीं चलाया है। इसलिए, मेरे पास कोई वास्तविक डेटा नहीं है।
यदि यह पता चला है कि स्काला में कुछ ओवरहेड wrt जावा है, तो क्या इसका मतलब मिश्रित स्काला / जावा प्रोजेक्ट है, जहां एक स्केल में अधिक जटिल भागों और जावा में प्रदर्शन-महत्वपूर्ण भागों को कोड करता है? क्या यह एक आम बात है?
EDIT 1
मैंने एक छोटा बेंचमार्क चलाया है: पूर्णांकों की एक सूची बनाएं, प्रत्येक पूर्णांक को दो से गुणा करें और इसे एक नई सूची में डालें, परिणामी सूची को प्रिंट करें। मैंने एक जावा कार्यान्वयन (जावा 6) और एक स्काला कार्यान्वयन (स्काला 2.9) लिखा। मैंने Ubuntu 10.04 के तहत ग्रहण इंडिगो पर दोनों चलाए हैं।
परिणाम तुलनात्मक हैं: जावा के लिए 480 एमएस और स्काला के लिए 493 एमएस (100 पुनरावृत्तियों पर औसत)। यहाँ मेरे द्वारा उपयोग किए गए स्निपेट्स हैं।
// 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))
}
तो, इस मामले में ऐसा लगता है कि स्काला ओवरहेड (रेंज, मैप, लैम्ब्डा का उपयोग करके) वास्तव में न्यूनतम है, जो वर्ल्ड इंजीनियर द्वारा दी गई जानकारी से दूर नहीं है।
हो सकता है कि अन्य स्कैला निर्माण हैं जिन्हें देखभाल के साथ उपयोग किया जाना चाहिए क्योंकि वे विशेष रूप से निष्पादित करने के लिए भारी हैं ?
EDIT 2
आप में से कुछ ने बताया कि प्रिंटल इनर लूप्स को निष्पादन के अधिकांश समय तक ले जाता है। मैंने उन्हें हटा दिया है और सूचियों का आकार 20000 के बजाय 100000 पर सेट कर दिया है। परिणामी औसत जावा के लिए 88 एमएस और स्काला के लिए 49 एमएस था।