Java में LinkedList vs ArrayList: कब और क्यों चुनें? पूरी गाइड

LinkedList या ArrayList: Java Collections की जंग

अगर आपने कभी Java में डेटा लिस्ट के साथ काम किया है, तो आपने यह दुविधा जरूर महसूस की होगी: LinkedList या ArrayList? यह सवाल Stack Overflow पर सबसे ज्यादा पूछे जाने वाले सवालों में से एक है, और हजारों डेवलपर्स इस पर चर्चा करते हैं। और यह कोई आश्चर्य की बात नहीं है। गलत डेटा स्ट्रक्चर चुनने से आपका तेज़ कोड धीमा हो सकता है, जबकि सही चुनाव आपके एप्लिकेशन को तेज़ और कुशल बना सकता है।

आज हम सिर्फ सूखे तथ्य नहीं बताएंगे। हम Java के अंदरूनी कामकाज को समझेंगे, देखेंगे कि ये कलेक्शन मेमोरी और प्रोसेसर स्तर पर कैसे काम करते हैं, और स्पष्ट जवाब देंगे: कब LinkedList का उपयोग करना चाहिए और कब ArrayList का। चलिए शुरू करते हैं!

संक्षेप में मुख्य बात: डॉक्यूमेंटेशन क्या कहता है

बुनियादी बातों से शुरू करते हैं। दोनों क्लासेस List इंटरफ़ेस को इम्प्लीमेंट करती हैं, लेकिन अलग-अलग तरीके से।

\n
• ArrayList — यह एक डायनामिक ऐरे है। यह एलिमेंट्स को मेमोरी के एक सतत ब्लॉक में स्टोर करता है। जब ऐरे भर जाता है, तो यह एक नया, बड़ा ऐरे बनाता है और सभी एलिमेंट्स को उसमें कॉपी कर देता है।
\n
• LinkedList — यह एक डबली लिंक्ड लिस्ट है। प्रत्येक एलिमेंट (नोड) में पिछले और अगले एलिमेंट के रेफरेंस होते हैं। प्रत्येक नोड के लिए अलग से मेमोरी आवंटित की जाती है।
\n

यह सुनने में सरल लगता है। लेकिन असली चीज़ डिटेल में छिपी है। आइए कोड देखें।

अंदरूनी कामकाज: व्यवहार में यह कैसे काम करता है

ArrayList: तेज़ एक्सेस, लेकिन बीच में इंसर्शन धीमा

import java.util.ArrayList;\nimport java.util.List;\n\npublic class ArrayListDemo {\n    public static void main(String[] args) {\n        List<String> arrayList = new ArrayList<>();\n        \n        // अंत में जोड़ना — तेज़ (एमॉर्टाइज़्ड O(1))\n        long start = System.nanoTime();\n        for (int i = 0; i < 100000; i++) {\n            arrayList.add("Element " + i);\n        }\n        long end = System.nanoTime();\n        System.out.println("ArrayList add (अंत में): " + (end - start) / 1e6 + " ms");\n        \n        // इंडेक्स द्वारा एक्सेस — तुरंत (O(1))\n        start = System.nanoTime();\n        String element = arrayList.get(50000);\n        end = System.nanoTime();\n        System.out.println("ArrayList get: " + (end - start) + " ns");\n        \n        // बीच में इंसर्शन — धीमा (O(n))\n        start = System.nanoTime();\n        arrayList.add(25000, "INSERTED");\n        end = System.nanoTime();\n        System.out.println("ArrayList insert (बीच में): " + (end - start) / 1e6 + " ms");\n    }\n}

यहाँ क्या हो रहा है? जब आप ArrayList के बीच में कोई एलिमेंट इंसर्ट करते हैं, तो इंसर्शन पॉइंट के दाईं ओर के सभी एलिमेंट एक पोजीशन शिफ्ट हो जाते हैं। यह एक O(n) ऑपरेशन है। अगर आपके पास दस लाख एलिमेंट हैं, तो यह दस लाख कॉपी ऑपरेशन होगा। बहुत दर्दनाक।

LinkedList: इंसर्शन में बादशाह, लेकिन एक्सेस में कमज़ोर

import java.util.LinkedList;\nimport java.util.List;\n\npublic class LinkedListDemo {\n    public static void main(String[] args) {\n        List<String> linkedList = new LinkedList<>();\n        \n        // अंत में जोड़ना — तेज़ (O(1))\n        long start = System.nanoTime();\n        for (int i = 0; i < 100000; i++) {\n            linkedList.add("Element " + i);\n        }\n        long end = System.nanoTime();\n        System.out.println("LinkedList add (अंत में): " + (end - start) / 1e6 + " ms");\n        \n        // इंडेक्स द्वारा एक्सेस — धीमा (O(n))\n        start = System.nanoTime();\n        String element = linkedList.get(50000);\n        end = System.nanoTime();\n        System.out.println("LinkedList get: " + (end - start) / 1e6 + " ms");\n        \n        // बीच में इंसर्शन — तेज़ (पोजीशन खोजने के बाद O(1))\n        start = System.nanoTime();\n        // ध्यान दें: add(index, element) मेथड खुद भी खोज करता है (O(n))\n        linkedList