लिस्ट में सबलिस्ट खोजने के लिए Java प्रोग्राम

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

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

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

इनपुट लिस्ट: [101, 102, 103, 104, 105, 106, 107, 108, 109]
शुरुआत इंडेक्स: 3
अंत इंडेक्स: 6

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

3 इंडेक्स पोजीशन से 6 इंडेक्स पोजीशन तक के एलिमेंट्स हैं: [104, 105, 106]

एल्गोरिदम

चरण 1 - शुरू
चरण 2 - एक इंटीजर लिस्ट घोषित करें जिसका नाम input_list हो
चरण 3 - मान परिभाषित करें
चरण 4 - इंडेक्स मान 3 और 6 के बीच सबलिस्ट बनाने के लिए subList(3,6) फंक्शन का उपयोग करें
चरण 5 - परिणाम प्रदर्शित करें
चरण 6 - रुकें

उदाहरण 1

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

import java.util.LinkedList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        int index_start = 3;
        int index_end = 6;
        List input_list = new LinkedList<>();
        
        for (int i = 1; i <= 9; i++) {
            input_list.add(i + 100);
        }
        
        System.out.println("लिस्ट परिभाषित है: " + input_list);
        List sublist = input_list.subList(index_start, index_end);
        System.out.println(index_start + " इंडेक्स पोजीशन से " + index_end + " इंडेक्स पोजीशन तक के एलिमेंट्स हैं: " + sublist);
    }
}

आउटपुट

लिस्ट परिभाषित है: [101, 102, 103, 104, 105, 106, 107, 108, 109]
3 इंडेक्स पोजीशन से 6 इंडेक्स पोजीशन तक के एलिमेंट्स हैं: [104, 105, 106]

उदाहरण 2

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

import java.util.LinkedList;
import java.util.List;

public class Demo {
    static void sublist(List input_list, int index_start, int index_end) {
        List sub = input_list.subList(index_start, index_end);
        System.out.println(index_start + " इंडेक्स पोजीशन से " + index_end + " इंडेक्स पोजीशन तक के एलिमेंट्स हैं: " + sub);
    }
    
    public static void main(String[] args) {
        int index_start = 3;
        int index_end = 6;
        List input_list = new LinkedList<>();
        
        for (int i = 1; i <= 9; i++) {
            input_list.add(i + 100);
        }
        
        System.out.println("लिस्ट परिभाषित है: " + input_list);
        sublist(input_list, index_start, index_end);
    }
}

आउटपुट

लिस्ट परिभाषित है: [101, 102, 103, 104, 105, 106, 107, 108, 109]
3 इंडेक्स पोजीशन से 6 इंडेक्स पोजीशन तक के एलिमेंट्स हैं: [104, 105, 106]

subList() महत्वपूर्ण विशेषताएं

• व्यू, कॉपी नहीं: subList मूल लिस्ट का व्यू लौटाता है, स्वतंत्र कॉपी नहीं
• बैकिंग लिस्ट पर प्रभाव: सबलिस्ट में परिवर्तन मूल लिस्ट को प्रभावित करते हैं और इसके विपरीत
• रेंज: fromIndex (समावेशी) से toIndex (अनन्य) - [fromIndex, toIndex)
• स्ट्रक्चरल मॉडिफिकेशन: बैकिंग लिस्ट पर स्ट्रक्चरल परिवर्तन सबलिस्ट को अमान्य कर देते हैं

सबलिस्ट ऑपरेशन्स

List list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
List sub = list.subList(3, 6);  // [4, 5, 6]

// सबलिस्ट के माध्यम से संशोधन (मूल को प्रभावित करता है)
sub.set(0, 99);        // list अब [1,2,3,99,5,6,7,8,9]
sub.add(10);           // list अब [1,2,3,99,5,6,10,7,8,9]
sub.remove(1);         // list अब [1,2,3,99,6,10,7,8,9]

// स्वतंत्र कॉपी बनाने के लिए
List independentCopy = new ArrayList<>(list.subList(3, 6));

// सबलिस्ट पर Stream ऑपरेशन्स
long count = list.subList(3, 6).stream().filter(x -> x > 5).count();

सामान्य त्रुटियां

• IndexOutOfBoundsException: यदि fromIndex < 0 या toIndex > size या fromIndex > toIndex
• ConcurrentModificationException: बैकिंग लिस्ट संशोधित होने पर सबलिस्ट पर इटरेट करना
• सीरियलाइज़ेशन: सबलिस्ट सीरियलाइज़ेबल नहीं है

विकल्प