क्यू जावा कलेक्शन फ्रेमवर्क क्या है?

उत्तर जावा कलेक्शन फ्रेमवर्क एक शक्तिशाली अंतर्निर्मित लाइब्रेरी है जो सबसे अधिक उपयोग किए जाने वाले डेटा संरचनाओं और एल्गोरिदम के अनुकूलित कार्यान्वयन का सेट प्रदान करता है। इसका व्यापक रूप से जावा अनुप्रयोगों के निर्माण और वास्तविक दुनिया के सॉफ्टवेयर विकास को हल करने में उपयोग किया जाता है। चुनौतियाँ।

जावा कलेक्शन फ्रेमवर्क के क्या फायदे हैं?

उत्तर जावा कलेक्शन फ्रेमवर्क के कुछ फायदे हैं

1. एकीकृत वास्तुकला: प्रत्येक डेटा संरचना सामान्य कार्यान्वयन की भावना प्रदान करने वाले पुनरावर्तनीय इंटरफ़ेस और संग्रह इंटरफ़ेस जैसे इंटरफेस से ली गई है।
2. उपयोग में आसानी : यह पूर्व-निर्मित डेटा संरचनाएं और एल्गोरिदम प्रदान करके विकास प्रक्रिया को सरल बनाता है। डेवलपर आमतौर पर उपयोग की जाने वाली डेटा संरचनाओं और मानक एल्गोरिदम को मैन्युअल रूप से लागू करने और अनुकूलित करने के बजाय व्यावसायिक तर्क पर अधिक ध्यान केंद्रित कर सकता है।
3. लचीलापन: यदि हम अंतर्निहित डेटा संरचनाओं को बदलना चाहते हैं, तो हम यह चिंता किए बिना आसानी से कर सकते हैं कि डेटा संरचना बदलने से डेटा पुनर्प्राप्ति और एक्सेस पैटर्न (ज्यादातर) बदल जाएंगे।
4. थ्रेड सुरक्षा : जैसे जावा अलग-अलग थ्रेड पर प्रक्रियाओं को अलग-अलग चलाने का एक तरीका प्रदान करता है, जावा कलेक्शन फ्रेमवर्क मल्टीथ्रेड एन्वोरिनमेंट और एकल थ्रेडेड अनुप्रयोगों में चलाने के लिए अलग-अलग कक्षाएं प्रदान करता है।

जावा संग्रह फ़्रेमवर्क पदानुक्रम

चलने योग्य इंटरफ़ेस
जावा में Iterable इंटरफ़ेस कलेक्शन फ्रेमवर्क का एक प्रमुख घटक है। यह सभी संग्रह प्रकारों के लिए रूट इंटरफ़ेस है जिसे पुनरावृत्त किया जा सकता है। Iterable इंटरफ़ेस को लागू करने से एक ऑब्जेक्ट को "प्रत्येक लूप के लिए" (जिसे लूप के लिए एन्हांस्ड के रूप में भी जाना जाता है) का लक्ष्य बनने की अनुमति मिलती है।
इसके अलावा यह एक पुनरावर्तक ऑब्जेक्ट भी प्रदान करता है जिसका उपयोग इस पुनरावृत्त इंटरफ़ेस को लागू करने वाले सभी डेटा संरचनाओं के आगे के पुनरावृत्ति के लिए किया जा सकता है।

प्रत्येक लूप के लिए उदाहरण (लूप के लिए उन्नत)

आंतरिक रूप से ArrayList सूची और सूची इंटरफ़ेस को लागू करता है, संग्रह इंटरफ़ेस का विस्तार करता है और संग्रह इंटरफ़ेस, Iterable इंटरफ़ेस का विस्तार करता है।

सूची सूची = नई ऐरेलिस्ट();//डेटा संरचना घोषित करना
list.add("Java");//तत्व जोड़ें
list.add("संग्रह");//तत्व जोड़ें
list.add("फ्रेमवर्क");//तत्व जोड़ें
के लिए (स्ट्रिंग तत्व: सूची) {// लूप के लिए एन्हांस्ड का उपयोग करके पुनरावृत्ति करना
System.out.println(तत्व);
}

ITERABLE ऑब्जेक्ट का उपयोग करने वाला उदाहरण

Iterator iterator = list.iterator();
जबकि (iterator.hasNext()) {
स्ट्रिंग तत्व = iterator.next();
System.out.println(तत्व);
}

इसलिए हम पुनरावर्तनीय इंटरफ़ेस को लागू करने और नेक्स्ट, हैनेक्स्ट और रिमूव विधि को ओवरराइड करने के लिए कस्टम पुनरावर्तनीय बना सकते हैं। यहाँ उसी का उदाहरण है।

import java.util.Iterator;
class CustomIterable implements Iterable {
    private final int[] numbers = {1, 2, 3, 4, 5};

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            private int lastReturnedIndex = -1;

            @Override
            public boolean hasNext() {
                return index 



टिप्पणी :

जावा में इटरेटर विफल होते हैं। इसका मतलब यह है कि यदि संग्रह को पुनरावृत्त करते समय संशोधित किया जाता है (पुनरावृत्तकर्ता की स्वयं की निष्कासन() विधि को छोड़कर), तो यह एक ConcurrentModificationException को फेंक देता है।
निकालें() विधि केवल तत्वों को हटा सकती है, और इसे अगले() पर प्रति कॉल केवल एक बार कॉल किया जाना चाहिए। अन्यथा, यह एक IllegalStateException फेंक देगा।

  
  
  संग्रह इंटरफ़ेस


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


//ArrayList
Collection c = new ArrayList():
c.add(1);
c.add(2);
c.contains(1);

Collection c1 = new LinkedList():
c1.addAll(c);//Array added to a linked list

/*What if i dont want arraylist but now i want a priority queue for applying efficient algorithms such as findmax and find min*/
//Just Change Object - SIMPLE!
Collection c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contains(1);




संग्रह इंटरफ़ेस के तरीके


int size : संग्रह का आकार लौटाता है।

बूलियन isEmpty : यदि संग्रह खाली है तो सत्य लौटाता है।

बूलियन में शामिल है (ऑब्जेक्ट ओ): यदि ऑब्जेक्ट ओ संग्रह में मौजूद है तो सत्य लौटाता है।

Iterator iterator() : एक संग्रह की ओर इंगित करने वाला पुनरावर्तक लौटाता है।

ऑब्जेक्ट[] toArray() : एक संग्रह को ऑब्जेक्ट प्रकार की एक सरणी में बदल देता है।

 T[] toArray(T[] a) : संग्रह के सभी तत्वों से युक्त एक सरणी लौटाता है; लौटाई गई सरणी का रनटाइम प्रकार निर्दिष्ट सरणी का है।

बूलियन ऐड(ई ई): संग्रह में तत्व ई जोड़ता है। यदि ऑपरेशन सफल होता है तो सत्य लौटाता है।

बूलियन रिमूव (ऑब्जेक्ट ओ): संग्रह से ऑब्जेक्ट ओ को हटाता है। यदि ऑपरेशन सफल होता है तो सत्य लौटाता है।

बूलियन includeAll(Collection> c) ​​: यदि दोनों संग्रहों में सभी तत्व समान हैं तो सत्य लौटाता है। यदि ऑपरेशन सफल होता है तो सत्य लौटाता है।
10.बूलियन ऐडऑल(कलेक्शन एक्सटेंड्स ई> सी) : दोनों कलेक्शन के सभी एलिमेंट जोड़ता है। यदि ऑपरेशन सफल होता है तो सत्य लौटाता है।

बूलियन रिमूवऑल(कलेक्शन> सी): कॉलर कलेक्शन से कलेक्शन सी के तत्व को हटाता है। यदि ऑपरेशन सफल होता है तो सत्य लौटाता है।

बूलियन रिटेनऑल(कलेक्शन> सी): केवल कलेक्शन सी में मौजूद तत्वों को बरकरार रखता है।

शून्य साफ़() : संग्रह से सभी तत्वों को साफ़ करता है।
संग्रह वर्ग को लागू करके हम एक कस्टम संग्रह बनाने के लिए उपरोक्त विधियों को ओवरराइड कर सकते हैं। नीचे इसका उदाहरण दिया गया है।


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection implements Collection {
    private final ArrayList list = new ArrayList();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index  T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean removeAll(Collection> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }
}







  
  
  सूची इंटरफ़ेस


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

सूची इंटरफ़ेस की मुख्य विशेषताएं:

आदेशित संग्रह: एक सूची तत्वों के सम्मिलन क्रम को संरक्षित करती है, जिसका अर्थ है कि तत्वों तक उनके सूचकांक द्वारा पहुंचा जा सकता है।
डुप्लिकेट की अनुमति देता है: एक सूची में डुप्लिकेट तत्व हो सकते हैं, सेट के विपरीत जो डुप्लिकेट की अनुमति नहीं देते हैं।
स्थितिगत पहुंच: किसी सूची में तत्वों को उनके सूचकांक द्वारा एक्सेस किया जा सकता है, जोड़ा या हटाया जा सकता है।
पुनरावृत्ति: सूची इंटरफ़ेस उन्नत फॉर-लूप के साथ-साथ Iterator या ListIterator का उपयोग करके पुनरावृत्ति की अनुमति देता है।
सूची इंटरफ़ेस के सामान्यतः प्रयुक्त तरीके:
सभी संग्रह इंटरफ़ेस विधियां सूची इंटरफ़ेस द्वारा भी कार्यान्वित की जाती हैं क्योंकि सूची इंटरफ़ेस संग्रह इंटरफ़ेस का विस्तार करता है।

void add(int Index, E element): इस सूची में निर्दिष्ट सूचकांक पर निर्दिष्ट तत्व E सम्मिलित करता है।
E get(int Index): इस सूची में निर्दिष्ट स्थान पर तत्व लौटाता है।
ई रिमूव(इंट इंडेक्स): इस सूची में निर्दिष्ट स्थान पर तत्व को हटाता है।
ई सेट (इंट इंडेक्स, ई तत्व): इस सूची में निर्दिष्ट स्थान पर तत्व को निर्दिष्ट तत्व से बदल देता है।
int IndexOf(ऑब्जेक्ट ओ): निर्दिष्ट तत्व की पहली घटना का सूचकांक लौटाता है, या -1 यदि सूची में तत्व शामिल नहीं है।
int LastIndexOf(ऑब्जेक्ट ओ): निर्दिष्ट तत्व की अंतिम घटना का सूचकांक लौटाता है, या -1 यदि सूची में तत्व शामिल नहीं है।
सूची उपसूची(int fromIndex, int toIndex): निर्दिष्ट fromIndex, समावेशी, और toIndex, विशेष के बीच इस सूची के हिस्से का दृश्य लौटाता है।

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Java");
        list.add("Collections");
        list.add("Framework");

        // Accessing elements by index
        System.out.println("First Element: "   list.get(0));

        // Removing an element by index
        list.remove(1);
        System.out.println("After Removal: "   list);

        // Updating an element
        list.set(1, "Updated Element");
        System.out.println("Updated List: "   list);

        // Using a sublist
        List sublist = list.subList(0, 1);
        System.out.println("Sublist: "   sublist);
    }
}