java - क्यों कलेक्शंस। एसओआरटी() अर्रेसे.सोर्ट() की तुलना में बहुत धीमा है




arrays list (4)

Collection.sort () मर्ज सॉर्ट एल्गोरिथ्म और Arrays.sort () त्वरित सॉर्ट का उपयोग करता है। त्वरित सॉर्ट में बड़ी कमियां हैं जब यह सॉर्ट करने के लिए आता है, तो यह स्थिर नहीं है, जबकि यह गैर आदिम है। इसलिए आवश्यकता पर निर्भर करता है कि हम Arrays.sort () या Collection.sort () मौसम का उपयोग वस्तुओं या प्राइमेटिक्स की तुलना करने के लिए करें।

मैंने एक परीक्षण करने की कोशिश की, Collection.sort() और Arrays.sort() । परीक्षण में, मैंने 1 एस 5 की लंबाई के 100 1e5 की एक सरणी बनाई, जिसमें 1 से 1e5 तक यादृच्छिक संख्याएं थीं। मैंने एक प्रकार की Integer सूची भी बनाई, जिसमें समान पदों पर समान मान सम्‍मिलित थे। फिर मैंने Arrays.sort() और Collections.sort() का उपयोग करके सूची को सॉर्ट किया।

अद्यतन: जैसा कि @Holger ने बताया, मेरे कोड में एक बग था। सही कोड अब है:

import java.util.* ;


class TestClass {
    public static void main(String args[] ) throws Exception {
        double ratSum = 0 ;
        for(int j=0;j<100;j++)
        {
        int[] A = new int[(int)1e5] ;
        List<Integer> L = new ArrayList<Integer>() ;
        for(int i=0;i<A.length;i++)
        {
            int no = (int)(Math.random()*(int)1e5) ;
            A[i] = no ;
            L.add(A[i]) ;
        }

        long startTime = System.nanoTime() ;
        Arrays.sort(A) ;
        long endTime = System.nanoTime() ;
        Collections.sort(L) ;
        long endTime2 = System.nanoTime() ;
        long t1 = (endTime-startTime), t2 = (endTime2-endTime) ;
        ratSum+=(double)t2/t1 ;
        System.out.println("Arrays.sort took :"+t1+" Collections.sort took :"+t2+" ratio :"+((double)t2/t1)) ;
    }
    System.out.println("Average ratio :"+(ratSum/100)) ;
    }
}

और आउटपुट है:

Arrays.sort took :24106021 Collections.sort took :92353602 ratio :3.8311425182944956
Arrays.sort took :8672831 Collections.sort took :50936497 ratio :5.873110752417521
Arrays.sort took :8561227 Collections.sort took :25611480 ratio :2.991566512603859
Arrays.sort took :7123928 Collections.sort took :17368785 ratio :2.4380910362934607
Arrays.sort took :6280488 Collections.sort took :16929218 ratio :2.6955258890710403
Arrays.sort took :6248227 Collections.sort took :16844915 ratio :2.695951187432851
Arrays.sort took :6220942 Collections.sort took :16979669 ratio :2.7294369566538315
Arrays.sort took :6213841 Collections.sort took :17439817 ratio :2.8066081832476883
Arrays.sort took :6286385 Collections.sort took :19963612 ratio :3.175690321225951
Arrays.sort took :6209668 Collections.sort took :17008307 ratio :2.7390042430609816
Arrays.sort took :6286623 Collections.sort took :17007163 ratio :2.705293923303497
Arrays.sort took :6256505 Collections.sort took :16911950 ratio :2.703098614961548
Arrays.sort took :6225031 Collections.sort took :16914494 ratio :2.7171742598550916
Arrays.sort took :6233918 Collections.sort took :17005995 ratio :2.72797861633727
Arrays.sort took :6210554 Collections.sort took :17606028 ratio :2.834856278522013
Arrays.sort took :6239384 Collections.sort took :20342378 ratio :3.260318326296314
Arrays.sort took :6207695 Collections.sort took :16519089 ratio :2.6610664666997974
Arrays.sort took :6227147 Collections.sort took :16605884 ratio :2.666692146499834
Arrays.sort took :6225187 Collections.sort took :16687597 ratio :2.680657946500242
Arrays.sort took :6152338 Collections.sort took :16475373 ratio :2.6779043999208105
Arrays.sort took :6184746 Collections.sort took :16511024 ratio :2.6696365541931715
Arrays.sort took :6130221 Collections.sort took :16578032 ratio :2.7043122915144493
Arrays.sort took :6271927 Collections.sort took :16507152 ratio :2.631910734930429
Arrays.sort took :6232482 Collections.sort took :16562166 ratio :2.657394919070765
Arrays.sort took :6218992 Collections.sort took :16552468 ratio :2.661599821964717
Arrays.sort took :6230427 Collections.sort took :21954967 ratio :3.52383022865046
Arrays.sort took :8204666 Collections.sort took :16607560 ratio :2.024160398485447
Arrays.sort took :6272619 Collections.sort took :22061291 ratio :3.5170781136236715
Arrays.sort took :8618253 Collections.sort took :19979549 ratio :2.3182829513127543
Arrays.sort took :6198538 Collections.sort took :17002645 ratio :2.743008915973412
Arrays.sort took :6265018 Collections.sort took :17079646 ratio :2.7261926462142645
Arrays.sort took :6302335 Collections.sort took :17040082 ratio :2.7037728080148073
Arrays.sort took :6293948 Collections.sort took :17133482 ratio :2.722215372608735
Arrays.sort took :6272364 Collections.sort took :17099717 ratio :2.7261997231028046
Arrays.sort took :6219540 Collections.sort took :17026849 ratio :2.737637992520347
Arrays.sort took :6231000 Collections.sort took :17149439 ratio :2.7522771625742255
Arrays.sort took :6309215 Collections.sort took :17118779 ratio :2.713297771592821
Arrays.sort took :6200511 Collections.sort took :17123517 ratio :2.7616299688848227
Arrays.sort took :6263169 Collections.sort took :16995685 ratio :2.7135919532109063
Arrays.sort took :6212243 Collections.sort took :17101848 ratio :2.7529264389689843
Arrays.sort took :6247580 Collections.sort took :17089850 ratio :2.735435160494143
Arrays.sort took :6283626 Collections.sort took :17088109 ratio :2.7194662763188004
Arrays.sort took :6312678 Collections.sort took :17055856 ratio :2.7018415955954036
Arrays.sort took :6222695 Collections.sort took :17071263 ratio :2.7433873908330715
Arrays.sort took :6300990 Collections.sort took :17016171 ratio :2.7005551508572463
Arrays.sort took :6262923 Collections.sort took :17084477 ratio :2.727875945465081
Arrays.sort took :6256482 Collections.sort took :17062232 ratio :2.7271287602202006
Arrays.sort took :6259643 Collections.sort took :17036036 ratio :2.721566709155778
Arrays.sort took :6248649 Collections.sort took :16944960 ratio :2.711779778316881
Arrays.sort took :6264515 Collections.sort took :16986876 ratio :2.7116027338109974
Arrays.sort took :6241864 Collections.sort took :17367903 ratio :2.782486609769133
Arrays.sort took :6297429 Collections.sort took :17080086 ratio :2.7122316107097038
Arrays.sort took :6184084 Collections.sort took :17584862 ratio :2.843567778186713
Arrays.sort took :6315776 Collections.sort took :22279278 ratio :3.5275598754610678
Arrays.sort took :6253047 Collections.sort took :17091694 ratio :2.7333384828228544
Arrays.sort took :6291188 Collections.sort took :17147694 ratio :2.725668665441249
Arrays.sort took :6327348 Collections.sort took :17034007 ratio :2.6921242517402235
Arrays.sort took :6284904 Collections.sort took :17049315 ratio :2.712740719667317
Arrays.sort took :6190436 Collections.sort took :17143853 ratio :2.7694096183209065
Arrays.sort took :6301712 Collections.sort took :17070237 ratio :2.7088253160411013
Arrays.sort took :6208193 Collections.sort took :17060372 ratio :2.74804149935416
Arrays.sort took :6247700 Collections.sort took :16961962 ratio :2.7149130079869392
Arrays.sort took :6344996 Collections.sort took :17084627 ratio :2.6926143058246215
Arrays.sort took :6214232 Collections.sort took :17150324 ratio :2.759846108095095
Arrays.sort took :6224359 Collections.sort took :17081254 ratio :2.744259127727048
Arrays.sort took :6256722 Collections.sort took :17005451 ratio :2.7179489515436357
Arrays.sort took :6286439 Collections.sort took :17061112 ratio :2.713954911516679
Arrays.sort took :6250634 Collections.sort took :17091313 ratio :2.7343327092899696
Arrays.sort took :6252900 Collections.sort took :17041659 ratio :2.7254008540037424
Arrays.sort took :6222192 Collections.sort took :17125062 ratio :2.75225547524088
Arrays.sort took :6227037 Collections.sort took :17013314 ratio :2.7321684454420296
Arrays.sort took :6223609 Collections.sort took :17086112 ratio :2.745370411283871
Arrays.sort took :6280777 Collections.sort took :17091821 ratio :2.7212908530266238
Arrays.sort took :6254551 Collections.sort took :17148242 ratio :2.741722307484582
Arrays.sort took :6250927 Collections.sort took :17053331 ratio :2.7281283240069834
Arrays.sort took :6270616 Collections.sort took :17067948 ratio :2.721893351466586
Arrays.sort took :6223093 Collections.sort took :17034584 ratio :2.737317922132933
Arrays.sort took :6286002 Collections.sort took :17128280 ratio :2.7248289135129133
Arrays.sort took :6239485 Collections.sort took :17032062 ratio :2.7297224049741287
Arrays.sort took :6191290 Collections.sort took :17017219 ratio :2.748574045150526
Arrays.sort took :6134110 Collections.sort took :17069485 ratio :2.782715830006309
Arrays.sort took :6207363 Collections.sort took :17052862 ratio :2.747199092432648
Arrays.sort took :6238702 Collections.sort took :17056945 ratio :2.734053493819708
Arrays.sort took :6185356 Collections.sort took :17006088 ratio :2.749411351585907
Arrays.sort took :6309226 Collections.sort took :17056503 ratio :2.703422416632405
Arrays.sort took :6256706 Collections.sort took :17082903 ratio :2.7303349398229675
Arrays.sort took :6194988 Collections.sort took :17069426 ratio :2.7553606237816766
Arrays.sort took :6184266 Collections.sort took :17054641 ratio :2.757746998592881
Arrays.sort took :6271022 Collections.sort took :17086036 ratio :2.724601508334686
Arrays.sort took :6246482 Collections.sort took :17077804 ratio :2.733987546910405
Arrays.sort took :6194985 Collections.sort took :17119911 ratio :2.763511291794895
Arrays.sort took :6319199 Collections.sort took :17444587 ratio :2.760569337980969
Arrays.sort took :6262827 Collections.sort took :17065589 ratio :2.7249018693954024
Arrays.sort took :6301245 Collections.sort took :17195611 ratio :2.728922776371971
Arrays.sort took :6214333 Collections.sort took :17024645 ratio :2.739577199998777
Arrays.sort took :6213116 Collections.sort took :17382033 ratio :2.7976353572024086
Arrays.sort took :6286394 Collections.sort took :17124874 ratio :2.7241171965995132
Arrays.sort took :6166308 Collections.sort took :16998293 ratio :2.756640278104824
Arrays.sort took :6247395 Collections.sort took :16957056 ratio :2.7142602636779007
Arrays.sort took :6245054 Collections.sort took :16994147 ratio :2.72121698227109
Average ratio :2.792654880602193

इसके अलावा, मैंने स्थानीय रूप से कोड, १००० बार (१०० के बजाय) चलाया और औसत अनुपात था:: ३.०६१६ तो, अनुपात अभी भी महत्वपूर्ण है और इस प्रकार चर्चा के योग्य है।

प्रश्न: समान मानों को क्रमबद्ध करने के लिए Arrays.sort() द्वारा लिया गया समय, लगभग 3 गुना Arrays.sort() क्यों लेता है? क्या इसलिए कि अब हम आदिमों की तुलना नहीं कर रहे हैं? अधिक समय क्यों लगेगा?


तो, यहाँ दो अलग-अलग तरीकों के साथ अलग-अलग एल्गोरिदम हैं:

Arrays.sort(int[]) एक डुअल- Arrays.sort(int[]) एल्गोरिथम का उपयोग करता है।

Collections.sort(List<T>) कॉल list.sort(null) जो बदले में Arrays.sort(T[]) कॉल Arrays.sort(T[]) । यह एक Timsort एल्गोरिथ्म का उपयोग करता है।

तो, आइए तुलना करें Arrays.sort(int[]) और Arrays.sort(T[])

  1. T[] एक बॉक्सिंग ऐरे है, इसलिए इनडायरेक्ट का एक अतिरिक्त स्तर है: प्रत्येक कॉल के लिए, आपको Integer को खोल देना है। यह निश्चित रूप से एक उपरि की ओर जाता है। दूसरी ओर, int[] एक आदिम सरणी है इसलिए सभी तत्व "तुरंत" उपलब्ध हैं।
  2. TimSort एक क्लासिक मर्जेस एल्गोरिथ्म का रूपांतर है। यह मर्जसॉर्ट से तेज है लेकिन यह अभी भी क्विकर की तुलना में धीमा है
    • quicksort यादृच्छिक डेटा पर कम डेटा आंदोलनों है
    • quicksort को O(log(n)) अतिरिक्त स्थान की आवश्यकता होती है जबकि TimSort को स्थिरता प्रदान करने के लिए O(n) आवश्यकता होती है जो ओवरहेड की ओर भी जाता है।

यहां दो समस्याएं हैं:

अंक 1:

कवर के तहत, कलेक्शन.शॉर्ट संग्रह को एक सरणी में कॉपी करके, सरणी को छांट कर, फिर संग्रह में वापस सरणी की प्रतिलिपि बनाकर काम करता है।

Arrays.sort जगह में सरणी को सॉर्ट करता है।

अब एक बड़े पर्याप्त सरणी / संग्रह के लिए, छंटाई की लागत ( O(NlogN )) प्रतिलिपि ( O(N) ) की लागत पर हावी होगी। एक छोटे से सरणी / संग्रह के लिए, नकल महत्वपूर्ण हो जाती है।

(यह व्यवहार संग्रह प्रकार पर निर्भर हो सकता है। एक ArrayList , Collections.sort Sort कार्यान्वयन डेटा की प्रतिलिपि के बिना बैकिंग सरणी को सॉर्ट करने में सक्षम हो सकता है। मुझे स्रोत कोड की जाँच करने की आवश्यकता होगी। UPDATE - इन-प्लेस सॉर्टिंग के लिए ArrayList की पुष्टि की गई है। जावा 8 और बाद में।)

अंक # 2:

आप एक List<Integer> को क्रमबद्ध करने के साथ एक int[] की छँटाई कर रहे हैं।

यह सेब और संतरे हैं। इसलिये:

  1. रिलेशनल ऑपरेटरों का उपयोग करते हुए दो Integer वैल्यू की तुलना करना तुलनात्मक compareTo(Integer) का उपयोग करते हुए दो Integer मूल्यों की तुलना में तेज है।
  2. Arrays.sort(int[]) Arrays.sort(Object[]) द्वारा उपयोग किए गए एक अलग (तेज) एल्गोरिदम का उपयोग करता है

यदि आप एक निष्पक्ष तुलना चाहते हैं, तो Arrays.sort(Object[]) तुलना एक ArrayList<Integer> पर Arrays.sort(Object[]) साथ एक Integer[]


वहाँ एक बात है जो रास्ते में उल्लेख नहीं किया गया था, जो "पॉइंटर चेज़िंग" है, जो "अनबॉक्सिंग" भाग से संबंधित है। इस छोटे आकार के एक सरणी के लिए, चाहे आप टाइमस्टॉर्ट या क्विकॉर्ट का उपयोग करें, एक महत्वपूर्ण अंतर नहीं होना चाहिए (वर्तमान सीपीयू गति के साथ आदिम सरणियों के लिए, यह बहुत संभव नहीं है जो आपकी गति को मारता है)।

जबकि बॉक्सिंग आपके उदाहरण में आरंभीकरण के बाहर नहीं होती है, बड़ा अंतर होता है जहां डेटा पढ़ा जाता है।

जैसे कि इन्टिमिटिव होते हैं, एक int [] केवल मेमोरी का एक सन्निहित टुकड़ा होता है जिसमें डेटा स्वयं होता है, एक Integer [] मेमोरी का एक सन्निहित टुकड़ा होता है जिसमें व्यक्तिगत डेटा ऑब्जेक्ट्स के संदर्भ (यानी पॉइंटर्स) होते हैं और Integer खुद ही कर सकते हैं। स्मृति भर में बिखरे हुए हो।

तो इंट पर एक तरह के ऑपरेशन के लिए [] सीपीयू मेमोरी का एक हिस्सा लेगा और सीधे उस पर काम कर सकता है। लेकिन एक इंटेगर के लिए [] सीपीयू को प्रत्येक व्यक्तिगत ऑब्जेक्ट के लिए पॉइंटर का पीछा करना पड़ता है और मेमोरी से प्राप्त होता है, इससे पहले कि वह इसकी तुलना कर सके और फिर मेमोरी के उस हिस्से पर काम करे जो सरणी है और इसे फिर से व्यवस्थित करें। इसे "पॉइंटर चेज़िंग" कहा जाता है।

यह इतना नहीं है कि इंटेगर [] को डेटा के प्रत्येक टुकड़े के लिए अधिक संचालन की आवश्यकता होती है, जैसे मान पढ़ना, आधार पते में हेडर की लंबाई जोड़ना और वहां से एक मूल्य प्राप्त करना (सीपीयू इन निर्देशों को बहुत अच्छी तरह से पाइपलाइन करता है और यह बहुत छुपाता है इसके प्रभाव से), यह स्मृति विलंबता है जो आपको मारती है। यादृच्छिक मेमोरी लोकेशन से प्रत्येक इंटेगर इंटेगर ऑब्जेक्ट को लाना लगभग सभी अंतर बनाता है।

आमतौर पर यह कोई बड़ी बात नहीं है, क्योंकि आमतौर पर आप तंग लूप में इंटेगर [] की कम मात्रा को इनिशियलाइज़ करते हैं और बैकग्राउंड में बहुत कुछ नहीं चल रहा होता है, इसलिए इंटेगर ऑब्जेक्ट्स के मेमोरी में बंद होने की संभावना होती है। कैश में और वहाँ से जल्दी से पहुँचा, लेकिन विशाल सरणियों और सूचियों के लिए जो एक व्यस्त एप्लिकेशन को बनाया और संशोधित किया गया है, यह एक महत्वपूर्ण अंतर ला सकता है और अप्रत्याशित विलंबता स्पाइक्स के साथ आ सकता है। आप इस बात से बचना चाहेंगे कि यदि आपको विश्वसनीय, निम्न अक्षांशों की आवश्यकता है। हालाँकि, बड़ी संख्या में अनुप्रयोगों के लिए, यदि कोई क्रम कुछ मिलीसेकंड अधिक लेता है, तो कोई भी नोटिस नहीं करता है।

[संपादित करें]

जैसा कि आपने टिप्पणी में इसके लिए कहा है, यहां यह दर्शाने के लिए कोड है कि यह टाइमसॉर्ट बनाम क्विकर के बारे में नहीं है:

import java.util.Arrays;
import java.util.Random;

public class Pointerchasing1 {

    public static void main(String[] args) {

        //use the exact same algorithm implementation (insertionSort), to show that slowness is not caused by timsort vs quicksort.
        //expect that the object-version is slower.

        final int[] direct = new int[1024]; 
        final Integer[] refs = new Integer[direct.length];

        final Random rnd = new Random(0);
        for (int t = 0; t < 1000; ++t) {
            Arrays.setAll(direct, index -> rnd.nextInt());
            Arrays.setAll(refs, index -> direct[index]); // boxing happens here

            //measure direct:
            long t1 = System.nanoTime();
            insertionSortPrimitive(direct);
            long e1 = System.nanoTime()-t1;
            //measure refs:         
            long t2 = System.nanoTime();
            insertionSortObjects(refs);
            long e2 = System.nanoTime()-t2;

            // use results, so compiler can't eliminate the loops
            System.out.println(Arrays.toString(direct));
            System.out.println(Arrays.toString(refs));
            System.out.println("-");            
            System.out.println(e1);
            System.out.println(e2);
            System.out.println("--");           
        }
    }

    private static void insertionSortPrimitive(final int[] arr) {
        int i, key, j;
        for (i = 1; i < arr.length; i++) {
            key = arr[i];
            j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            arr[j + 1] = key;
        }
    }

    private static void insertionSortObjects(final Integer[] arr) {
        int i, key, j;
        for (i = 1; i < arr.length; i++) {
            key = arr[i];
            j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            arr[j + 1] = key;
        }
    }

}

यह "परीक्षण" संभव अपराधी के रूप में अनबॉक्सिंग छोड़ देता है।

[EDIT2]

अब यह परीक्षण यह दिखाना है कि "अनबॉक्सिंग" समस्या नहीं है। Unboxing बस पता करने के लिए वस्तुओं के हेडर के कुछ बाइट्स जोड़ रहा है (आउट-ऑफ-ऑर्डर-एक्ज़ीक्यूशन और पाइपलाइनिंग उस लागत को लगभग गायब कर देता है) और उस स्थान से मूल्य प्राप्त कर रहा है। इस परीक्षण में मैं दो आदिम सरणियों का उपयोग करता हूं, एक संदर्भ के लिए और एक मूल्य के लिए। इसलिए प्रत्येक पहुंच अप्रत्यक्ष है। यह बहुत ही unboxing की तरह है, बस वस्तु हेडर के लिए कुछ बाइट्स अतिरिक्त जोड़ने के बिना। मुख्य अंतर यह है कि "अप्रत्यक्ष" संस्करण को ढेर पर प्रत्येक मूल्य के लिए पॉइंटर का पीछा करने की आवश्यकता नहीं है, यह एआर और सरणी दोनों से मानों-सरणी में एरे और इंडेक्स दोनों को लोड कर सकता है।

यदि पॉइंटर चेज़िंग, अनबॉक्सिंग के बजाय अंतर करता है, तो अप्रत्यक्ष संस्करण उन ऑब्जेक्ट्स संस्करण की तुलना में तेज़ होना चाहिए जो अनबॉक्सिंग करते हैं।

import java.util.Arrays;
import java.util.Random;

public class Pointerchasing2 {

    public static void main(String[] args) {

        // use indirect access (like unboxing, but just chasing a single array pointer) vs. Integer objects (chasing every object's pointer).
        // expect that the object-version is still slower.

        final int[] values = new int[1024];
        final int[] refs = new int[1024];
        final Integer[] objects = new Integer[values.length];

        final Random rnd = new Random(0);
        for (int t = 0; t < 1000; ++t) {
            Arrays.setAll(values, index -> rnd.nextInt());
            Arrays.setAll(refs, index -> index);
            Arrays.setAll(objects, index -> values[index]); // boxing happens here

            // measure indirect:
            long t1 = System.nanoTime();
            insertionSortPrimitiveIndirect(refs, values);
            long e1 = System.nanoTime() - t1;
            // measure objects:
            long t2 = System.nanoTime();
            insertionSortObjects(objects);
            long e2 = System.nanoTime() - t2;

            // use results, so compiler can't eliminate the loops
            System.out.println(Arrays.toString(indirectResult(refs, values)));
            System.out.println(Arrays.toString(objects));
            System.out.println("-");
            System.out.println(e1);
            System.out.println(e2);
            System.out.println("--");
        }
    }

    private static void insertionSortPrimitiveIndirect(final int[] refs, int[] values) {
        int i, keyIndex, j;
        for (i = 1; i < refs.length; i++) {
            keyIndex = refs[i];
            j = i - 1;
            while (j >= 0 && values[refs[j]] > values[keyIndex]) {
                refs[j + 1] = refs[j];
                j = j - 1;
            }
            refs[j + 1] = keyIndex;
        }
    }

    private static void insertionSortObjects(final Integer[] arr) {
        int i, key, j;
        for (i = 1; i < arr.length; i++) {
            key = arr[i];
            j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            arr[j + 1] = key;
        }
    }

    private static int[] indirectResult(final int[] refs, int[] values) {
        final int[] result = new int[1024];
        Arrays.setAll(result, index -> values[refs[index]]);
        return result;
    }

}

परिणाम: इन दोनों परीक्षणों में, "आदिम" और "अप्रत्यक्ष" संस्करण, ढेर पर वस्तुओं तक पहुँचने की तुलना में तेज़ हैं। यह उम्मीद की जानी चाहिए कि अनबॉक्सिंग गति को नहीं मार रहा है, लेकिन सूचक चेज़िंग के माध्यम से मेमोरी लेटेंसी।

इस वीडियो को प्रोजेक्ट वल्लाह पर भी देखें: ("JVM के भीतर मूल्य प्रकार और सामान्य विशेषज्ञता हमें बेहतर JIT कोड देने का वादा करती है, डेटा स्थानीयता और पॉइंटर चेज़िंग के अत्याचार को दूर करती है।") https://vimeo.com/289667280 vimeo -289667280





timing