सभी संग्रहों की सूची

"हाय, अमीगो।"

"अरे, ऋषि।"

"एली ने मुझे बताया कि आप संग्रह के और उदाहरण चाहते हैं। मैं आपको कुछ देता हूँ। यहाँ संग्रह और इंटरफेस की एक सूची है:"

"हम्म। यह काफी है। चार सूचियाँ, तीन सेट और चार मानचित्र।"

"हां, वे सभी सूची, सेट और मैप इंटरफेस के अलग-अलग कार्यान्वयन हैं।"

"इन कार्यान्वयनों में क्या अंतर है?"

"ठीक यही बात आज हम बात करने जा रहे हैं। बस धैर्य रखें।"

"क्या आपके पास कोई अन्य प्रश्न है?"

"मुझे पता है कि स्क्रीन पर एक सूची कैसे प्रदर्शित की जाती है। मैं एक सेट या मानचित्र कैसे प्रदर्शित करूं?"

"एक सूची के तत्वों में एक सेट ऑर्डर होता है, इसलिए आप उन्हें प्रदर्शित करने के लिए केवल एक इंडेक्स का उपयोग कर सकते हैं। सेट या मैप के लिए, कोई विशिष्ट ऑर्डर नहीं है। वास्तव में, आइटम हटाए जाने या नए होने पर उनके तत्वों का क्रम बदल सकता है आइटम जोड़े जाते हैं।"

"अद्भुत।"

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

"यहां कुछ उदाहरण दिए गए हैं:"

 public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

     // Get an iterator for the set
     Iterator&ltString> iterator = set.iterator();

    while (iterator.hasNext())        // Check if there is another element
    {
       // Get the current element and move to the next one
       String text = iterator.next();

        System.out.println(text);
    }
}
 

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

    Iterator&ltString> iterator = list.iterator();// Get an iterator for the list

    while (iterator.hasNext())      // Check if there is another element   
    {
        // Get the current element and move to the next one
        String text = iterator.next();

        System.out.println(text);
    }
}

public static void main(String[] args)
{
    // All elements are stored in pairs
    Map<String, String> map = new HashMap<String, String>();
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();

   while (iterator.hasNext())
    {
        // Get a key-value pair
        Map.Entry<String, String> pair = iterator.next();
        String key = pair.getKey();            // Key
        String value = pair.getValue();        // Value
        System.out.println(key + ":" + value);
    }
}

"वाह। मुझे आश्चर्य है कि इसका क्या मतलब है।"

"यह वास्तव में काफी सरल है। सबसे पहले, हमें संग्रह से एक विशेष वस्तु, एक पुनरावर्तक मिलता है। पुनरावर्तक के पास केवल दो विधियाँ होती हैं।

1. अगली () विधि संग्रह में अगला तत्व लौटाती है।

2. hasNext () विधि यह जांचती है कि क्या अभी भी ऐसे तत्व हैं जो अगले () द्वारा वापस नहीं किए गए हैं।

"ठीक है। मुझे लगता है कि अब यह स्पष्ट हो रहा है। मुझे जो कुछ समझ आया उसे मैं आपको दोहराने की कोशिश करता हूं।"

"तो... सबसे पहले, हमें इस मैजिक इटरेटर ऑब्जेक्ट को प्राप्त करने के लिए संग्रह पर इटरेटर() विधि को कॉल करने की आवश्यकता है।"

"फिर हम तत्वों को एक-एक करके एक-एक करके प्राप्त करते हैं, जब तक कि प्राप्त करने के लिए कुछ बचा हो। हम अगले () कॉल करके संग्रह में अगला तत्व प्राप्त करते हैं, और हम जाँचते हैं कि क्या संग्रह में अभी भी तत्व हैं या नहीं है अगला () पर कॉल करके पुनरावर्तक। क्या यह सही है?"

"हाँ, कम या ज्यादा। लेकिन अच्छे हिस्से की प्रतीक्षा करें।"

"जावा में पुनरावर्तकों के साथ काम करने के लिए आशुलिपि संकेतन है। जबकि और के पैटर्न के बाद , एक और विशेष कथन जोड़ा गया है: प्रत्येक के लिए । इसे के लिए कीवर्ड का उपयोग करने का भी संकेत दिया गया है ।"

"प्रत्येक के लिए कथन केवल संग्रह और कंटेनरों के साथ काम करने के लिए उपयोग किया जाता है। यह एक पुनरावर्तक का उपयोग करता है, लेकिन हम केवल लौटाए गए तत्व को देखते हैं।"

"मैं आपको इटरेटर के साथ काम करने के लिए लांगहैंड और शॉर्टहैंड तरीके दिखाता हूं:"

public static void main(String[] args)
{
  Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    Iterator&ltString> iterator = set.iterator();
  while (iterator.hasNext())
  {
    String text = iterator.next();
    System.out.println(text);
  }
}

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

   for (String text : set)   
    {
        System.out.println(text);
    }
}

"ध्यान दें कि लाल या हरे रंग में हाइलाइट किए गए शब्द दाहिने हिस्से में अनुपस्थित हैं। वास्तव में, तीन पंक्तियों को एक से बदल दिया गया है:"

Iterator&ltString> iterator = set.iterator();
while (iterator.hasNext())
{
    String text = iterator.next();

for (String text : set)

"यह बहुत खूबसूरत लग रहा है। मुझे यह इस तरह से बहुत अच्छा लगता है।"

"आइए उपरोक्त उदाहरणों के संक्षिप्त संस्करण को देखें:"

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    for (String text : set)   
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

     for (String text : list)        
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    Map<String, String> map = new HashMap<String, String>(); 
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    for (Map.Entry<String, String> pair : map.entrySet())
    {
        String key = pair.getKey();                      // Key
        String value = pair.getValue();                  // Value
        System.out.println(key + ":" + value);
    }
}

"अब आप बात कर रहे हैं!"

"मुझे खुशी है कि तुम्हें इसे पसंद किया है।"