सर्व संग्रहांची यादी

"हाय, अमिगो."

"अरे, ऋषी."

"एलीने मला सांगितले की तुम्हाला संग्रहांची आणखी उदाहरणे हवी आहेत. मी तुम्हाला काही देईन. येथे संग्रह आणि इंटरफेसची सूची आहे:"

"हम्म. ते खूप आहे. चार याद्या, तीन सेट आणि चार नकाशे."

"होय, ते सर्व सूची, सेट आणि नकाशा इंटरफेसची भिन्न अंमलबजावणी आहेत."

"या अंमलबजावणीमध्ये काय फरक आहे?"

"आज आपण नेमके तेच बोलणार आहोत. जरा धीर धरा."

"तुला आणखी काही प्रश्न आहेत का?"

"मला स्क्रीनवर सूची कशी प्रदर्शित करायची हे माहित आहे. मी सेट किंवा नकाशा कसा प्रदर्शित करू?"

"यादीतील घटकांना एक संच क्रम असतो, त्यामुळे तुम्ही त्यांना प्रदर्शित करण्यासाठी फक्त अनुक्रमणिका वापरू शकता. संच किंवा नकाशासाठी, कोणताही विशिष्ट क्रम नाही. वस्तुतः, आयटम हटवल्या गेल्या किंवा नवीन झाल्यामुळे त्यांच्या घटकांचा क्रम बदलू शकतो. आयटम जोडले आहेत."

"आश्चर्यकारक."

"म्हणूनच विशेष वस्तू, ज्यांना पुनरावृत्ती म्हणतात, संग्रह घटकांसह कार्य करण्यासाठी शोधले गेले. ते आपल्याला संग्रहातील सर्व घटकांमधून जाऊ देतात, जरी त्यांना निर्देशांकांऐवजी (नकाशा), किंवा नावे किंवा निर्देशांक नसले तरीही ( सेट करा)."

"येथे काही उदाहरणे आहेत:"

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

     // Get an iterator for the set
     Iterator<String> 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<String> list = new ArrayList<String>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

    Iterator<String> 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() पद्धत पुढील() द्वारे परत न केलेले घटक अजूनही आहेत का ते तपासते."

"ठीक आहे. मला वाटते आता ते अधिक स्पष्ट होत आहे. मला जे समजले ते मी पुन्हा सांगण्याचा प्रयत्न करूया."

"म्हणून... प्रथम, हे जादूचे पुनरावृत्ती करणारे ऑब्जेक्ट मिळविण्यासाठी आम्हाला संग्रहावर iterator() पद्धत कॉल करणे आवश्यक आहे."

"मग जेवढे काही मिळायचे बाकी आहे तोपर्यंत आम्हाला एक एक करून घटक मिळतात. आम्हाला नेक्स्ट() वर कॉल करून संग्रहातील पुढील घटक मिळतात आणि आम्ही hasNext() वर कॉल करून संग्रहात अजून काही घटक आहेत का ते तपासतो. पुनरावृत्ती करणारा. ते बरोबर आहे का?"

"हो, कमी-जास्त. पण चांगल्या भागाची वाट बघ."

"जावामध्ये पुनरावृत्ती करणार्‍यांसह कार्य करण्यासाठी लघुलेखन आहे. while आणि for च्या पॅटर्नचे अनुसरण करून , आणखी एक विशेष विधान जोडले गेले आहे: प्रत्येकासाठी . ते . साठी कीवर्ड वापरून देखील सूचित केले आहे ."

"प्रत्येक विधानासाठी हे केवळ संग्रह आणि कंटेनरसह कार्य करण्यासाठी वापरले जाते. ते स्पष्टपणे पुनरावृत्ती करणारे वापरते, परंतु आम्ही फक्त परत केलेला घटक पाहतो."

"मी तुम्हाला इटरेटरसह काम करण्यासाठी लाँगहँड आणि शॉर्टहँड मार्ग दाखवतो:"

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

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

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

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

"लक्षात ठेवा की लाल किंवा हिरव्या रंगात ठळक केलेले शब्द उजव्या भागात अनुपस्थित आहेत. खरं तर, तीन ओळी एकाने बदलल्या आहेत:"

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

for (String text : set)

"हे सुंदर दिसत आहे. मला या मार्गाने खूप चांगले वाटते."

"वरील उदाहरणांची शॉर्टहँड आवृत्ती पाहू:"

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

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

public static void main(String[] args)
{
    List<String> list = new ArrayList<String>();
    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);
    }
}

"आता तू बोलतेस!"

"तुला ते आवडले याचा मला आनंद आहे."