लिस्ट इनिशियलाइज़ करने के लिए Java प्रोग्राम

इस लेख में, हम समझेंगे कि लिस्ट कैसे इनिशियलाइज़ करें। एक लिस्ट एक क्रमबद्ध संग्रह है जो हमें एलिमेंट्स को क्रमिक रूप से स्टोर और एक्सेस करने की अनुमति देती है। इसमें एलिमेंट्स को इंसर्ट, अपडेट, डिलीट और खोजने के लिए इंडेक्स-आधारित मेथड्स होते हैं। इसमें डुप्लिकेट एलिमेंट्स भी हो सकते हैं।

नीचे इसका प्रदर्शन है:

मान लीजिए हमारा इनपुट है:

प्रोग्राम चलाएं

वांछित आउटपुट होगा:

एक इंटीजर लिस्ट इनिशियलाइज़ कर रहे हैं
इंटीजर लिस्ट के एलिमेंट्स हैं: [25, 60]
एक स्ट्रिंग लिस्ट इनिशियलाइज़ कर रहे हैं
स्ट्रिंग लिस्ट के एलिमेंट्स हैं: [Java, Program]

एल्गोरिदम

चरण 1 - शुरू
चरण 2 - एक इंटीजर लिस्ट घोषित करें जिसका नाम integer_list हो और एक स्ट्रिंग लिस्ट जिसका नाम string_list हो
चरण 3 - मान परिभाषित करें
चरण 4 - इंटीजर लिस्ट इनिशियलाइज़ करने के लिए List integer_list = new ArrayList() का उपयोग करें
चरण 5 - स्ट्रिंग लिस्ट इनिशियलाइज़ करने के लिए List string_list = new ArrayList() का उपयोग करें
चरण 6 - लिस्ट में आइटम्स जोड़ने के लिए .add() फंक्शन का उपयोग करें
चरण 7 - परिणाम प्रदर्शित करें
चरण 8 - रुकें

उदाहरण 1

यहाँ, हम सभी ऑपरेशन्स को 'main' फंक्शन के तहत बांधते हैं।

import java.util.*;

public class Demo {
    public static void main(String args[]) {
        System.out.println("आवश्यक पैकेज आयात किए गए हैं");
        System.out.println("\nएक इंटीजर लिस्ट इनिशियलाइज़ कर रहे हैं");
        List integer_list = new ArrayList();
        integer_list.add(25);
        integer_list.add(60);
        System.out.println("इंटीजर लिस्ट के एलिमेंट्स हैं: " + integer_list.toString());
        
        System.out.println("\nएक स्ट्रिंग लिस्ट इनिशियलाइज़ कर रहे हैं");
        List string_list = new ArrayList();
        string_list.add("Java");
        string_list.add("Program");
        System.out.println("स्ट्रिंग लिस्ट के एलिमेंट्स हैं: " + string_list.toString());
    }
}

आउटपुट

आवश्यक पैकेज आयात किए गए हैं
एक इंटीजर लिस्ट इनिशियलाइज़ कर रहे हैं
इंटीजर लिस्ट के एलिमेंट्स हैं: [25, 60]
एक स्ट्रिंग लिस्ट इनिशियलाइज़ कर रहे हैं
स्ट्रिंग लिस्ट के एलिमेंट्स हैं: [Java, Program]

उदाहरण 2

यहाँ, हम ऑपरेशन्स को फंक्शन्स में एनकैप्सुलेट करते हैं जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रदर्शित करते हैं।

import java.util.*;

public class Demo {
    static void initialize_int_list() {
        List integer_list = new ArrayList();
        integer_list.add(25);
        integer_list.add(60);
        System.out.println("इंटीजर लिस्ट के एलिमेंट्स हैं: " + integer_list.toString());
    }
    
    static void initialize_string_list() {
        List string_list = new ArrayList();
        string_list.add("Java");
        string_list.add("Program");
        System.out.println("स्ट्रिंग लिस्ट के एलिमेंट्स हैं: " + string_list.toString());
    }
    
    public static void main(String args[]) {
        System.out.println("आवश्यक पैकेज आयात किए गए हैं");
        System.out.println("\nएक इंटीजर लिस्ट इनिशियलाइज़ कर रहे हैं");
        initialize_int_list();
        System.out.println("\nएक स्ट्रिंग लिस्ट इनिशियलाइज़ कर रहे हैं");
        initialize_string_list();
    }
}

आउटपुट

आवश्यक पैकेज आयात किए गए हैं
एक इंटीजर लिस्ट इनिशियलाइज़ कर रहे हैं
इंटीजर लिस्ट के एलिमेंट्स हैं: [25, 60]
एक स्ट्रिंग लिस्ट इनिशियलाइज़ कर रहे हैं
स्ट्रिंग लिस्ट के एलिमेंट्स हैं: [Java, Program]

लिस्ट इनिशियलाइज़ेशन के आधुनिक तरीके (Java 9+)

तरीका	सिंटैक्स	विशेषताएं
List.of() (अपरिवर्तनीय)	List.of(1, 2, 3)	कॉम्पैक्ट, थ्रेड-सेफ, नल नहीं
Arrays.asList()	Arrays.asList(1, 2, 3)	फिक्स्ड-साइज़, ऐरे-बैक्ड
Stream.of()	Stream.of(1,2,3).collect(toList())	फ्लेक्सिबल, फिल्टर/मैप चेनिंग
डबल ब्रेस (एंटी-पैटर्न)	new ArrayList(){{add(1);add(2);}}	अनाम क्लास, मेमोरी लीक जोखिम
कलेक्शन फैक्टरी (Java 10+)	List.copyOf(list)	अपरिवर्तनीय कॉपी बनाता है

List.of() उदाहरण

// Java 9+ - अपरिवर्तनीय लिस्ट
List immutable = List.of("Java", "Python", "Scala");
List numbers = List.of(1, 2, 3, 4, 5);

// खाली लिस्ट
List empty = List.of();

// नल नहीं जोड़ सकते - NPE फेंकता है
// List.of("A", null); // NullPointerException

// मॉडिफिएबल लिस्ट बनाने के लिए
List modifiable = new ArrayList<>(List.of("A", "B", "C"));

लिस्ट कार्यान्वयन चुनना

कार्यान्वयन	उपयोग करें जब	समय जटिलता
ArrayList	फ्रीक्वेंट रैंडम एक्सेस, कम इंसर्शन/डिलीशन	get: O(1), add: O(1)*
LinkedList	फ्रीक्वेंट इंसर्शन/डिलीशन, क्रमिक एक्सेस	get: O(n), add: O(1)
Vector	थ्रेड-सेफ आवश्यक (विरासत)	सिंक्रोनाइज़्ड, धीमा
CopyOnWriteArrayList	कई रीडर्स, कम राइटर्स, थ्रेड-सेफ	get: O(1), add: O(n)

क्षमता पूर्व-आवंटन

// अनुमानित आकार ज्ञात होने पर - रीसाइज़िंग से बचाता है
List list = new ArrayList<>(1000);  // प्रारंभिक क्षमता 1000

// सटीक आकार के लिए
List list = new ArrayList<>(Collections.nCopies(100, 0));  // 100 जीरोज़