मुझे जावा स्रोत में देखकर आश्चर्य हुआ कि System.arraycopy एक देशी विधि है।
बेशक कारण यह है क्योंकि यह तेज है। लेकिन क्या देशी तरकीब है जो कोड को नियोजित करने में सक्षम है जो इसे और तेज कर सकता है?
मूल सरणी पर सिर्फ लूप क्यों नहीं और प्रत्येक सूचक को नए सरणी में कॉपी करें - निश्चित रूप से यह धीमा और बोझिल नहीं है?
जवाबों:
मूल कोड में, इसे एक ही memcpy/ के साथ किया जा सकता है memmove, जैसा कि n अलग कॉपी ऑपरेशन के विपरीत है । प्रदर्शन में अंतर पर्याप्त है।
arraycopyउपयोग किया जा सकता है memcpy/ memmove। दूसरों को कॉपी किए गए प्रत्येक तत्व के लिए रनटाइम प्रकार की जांच की आवश्यकता होती है।
Object[]आबादी से Stringवस्तुओं की नकल करने पर विचार करें String[]। Java.sun.com/javase/6/docs/api/java/lang/…
यह जावा में नहीं लिखा जा सकता। मूल कोड ऑब्जेक्ट की सरणियों और प्राथमिकताओं के सरणियों के बीच के अंतर को अनदेखा या समाप्त करने में सक्षम है। जावा ऐसा नहीं कर सकता, कम से कम कुशलता से नहीं।
और यह एक के साथ नहीं लिखा जा सकता है memcpy(), क्योंकि ओवरलैपिंग सरणियों द्वारा आवश्यक शब्दार्थ के कारण।
memmoveतो। हालांकि मुझे नहीं लगता कि यह इस प्रश्न के संदर्भ में बहुत अंतर करता है।
यह, निश्चित रूप से, कार्यान्वयन निर्भर है।
हॉटस्पॉट इसे "इंट्रिंसिक" के रूप में मानेगा और कॉल साइट पर कोड डालेगा। यह मशीन कोड है, पुराना C कोड धीमा नहीं है। इसका मतलब यह भी है कि विधि के हस्ताक्षर के साथ समस्याएं काफी हद तक दूर हो जाती हैं।
एक साधारण कॉपी लूप इतना सरल है कि उस पर स्पष्ट अनुकूलन लागू किया जा सकता है। उदाहरण के लिए लूप का अनियंत्रित होना। वास्तव में क्या होता है फिर से कार्यान्वयन निर्भर है।
अपने स्वयं के परीक्षणों में कई आयाम सरणियों की प्रतिलिपि बनाने के लिए System.arraycopy () लूप को इंटरलेयर करने की तुलना में 10 से 20 गुना तेज है:
float[][] foo = mLoadMillionsOfPoints(); // result is a float[1200000][9]
float[][] fooCpy = new float[foo.length][foo[0].length];
long lTime = System.currentTimeMillis();
System.arraycopy(foo, 0, fooCpy, 0, foo.length);
System.out.println("native duration: " + (System.currentTimeMillis() - lTime) + " ms");
lTime = System.currentTimeMillis();
for (int i = 0; i < foo.length; i++)
{
for (int j = 0; j < foo[0].length; j++)
{
fooCpy[i][j] = foo[i][j];
}
}
System.out.println("System.arraycopy() duration: " + (System.currentTimeMillis() - lTime) + " ms");
for (int i = 0; i < foo.length; i++)
{
for (int j = 0; j < foo[0].length; j++)
{
if (fooCpy[i][j] != foo[i][j])
{
System.err.println("ERROR at " + i + ", " + j);
}
}
}
यह प्रिंट:
System.arraycopy() duration: 1 ms
loop duration: 16 ms
System.arraycopyएक उथली प्रतिलिपि करता है (केवल आंतरिक s के संदर्भों कीfloat[] प्रतिलिपि बनाई जाती है), जबकि आपके नेस्टेड- forलूप एक गहरी प्रतिलिपि बनाते हैं (float द्वारा float) करते हैं। एक परिवर्तन का उपयोग करने fooCpy[i][j]में परिलक्षित होगा , लेकिन नेस्टेड- लूप का उपयोग नहीं किया जाएगा । fooSystem.arraycopyfor
कुछ कारण हैं:
JIT मैन्युअल रूप से लिखित C कोड के रूप में कुशल निम्न स्तर कोड उत्पन्न करने की संभावना नहीं है। निम्न स्तर C का उपयोग बहुत सारे अनुकूलन को सक्षम कर सकता है जो सामान्य जेआईटी कंपाइलर के लिए असंभव है।
हाथ से लिखी सी कार्यान्वयन (मेम्पी, लेकिन सिद्धांत समान है) की कुछ ट्रिक्स और गति तुलना के लिए इस लिंक को देखें: इस ऑप्टिमाइज़िंग मेम्पी की जांच करें गति में सुधार
सी संस्करण सरणी सदस्यों के प्रकार और आकार से बहुत अधिक स्वतंत्र है। जावा में भी ऐसा करना संभव नहीं है क्योंकि स्मृति के कच्चे ब्लॉक के रूप में सरणी सामग्री प्राप्त करने का कोई तरीका नहीं है (जैसे। सूचक)।