அனைத்து தொகுப்புகளின் பட்டியல்

"வணக்கம், அமிகோ."

"ஏய், ரிஷி."

"எல்லி என்னிடம் இன்னும் சில தொகுப்புகளின் எடுத்துக்காட்டுகள் வேண்டும் என்று கூறினார். நான் உங்களுக்கு சிலவற்றைத் தருகிறேன். சேகரிப்புகள் மற்றும் இடைமுகங்களின் பட்டியல் இதோ:"

"ஹ்ம்ம். அது மிகவும் அதிகம். நான்கு பட்டியல்கள், மூன்று தொகுப்புகள் மற்றும் நான்கு வரைபடங்கள்."

"ஆம், அவை அனைத்தும் பட்டியல், தொகுப்பு மற்றும் வரைபட இடைமுகங்களின் வெவ்வேறு செயலாக்கங்கள்."

"இந்த செயலாக்கங்களுக்கு என்ன வித்தியாசம்?"

"அதைத்தான் இன்று பேசப் போகிறோம். பொறுமையாக இருங்கள்."

"உங்களுக்கு வேறு ஏதேனும் கேள்விகள் உள்ளதா?"

"எனக்குத் திரையில் பட்டியலைக் காட்டுவது எப்படி என்று தெரியும். ஒரு செட் அல்லது வரைபடத்தை எப்படிக் காட்டுவது?"

"பட்டியலின் கூறுகள் ஒரு செட் வரிசையைக் கொண்டுள்ளன, எனவே அவற்றைக் காண்பிக்க நீங்கள் ஒரு குறியீட்டைப் பயன்படுத்தலாம். ஒரு தொகுப்பு அல்லது வரைபடத்திற்கு, குறிப்பிட்ட வரிசை எதுவும் இல்லை. உண்மையில், உருப்படிகள் நீக்கப்பட்டாலும் அல்லது புதியதாக இருந்தாலும் அவற்றின் உறுப்புகளின் வரிசை மாறலாம். பொருட்கள் சேர்க்கப்படுகின்றன."

"அற்புதம்."

"இதனால்தான் இடிரேட்டர்கள் எனப்படும் சிறப்புப் பொருள்கள், சேகரிப்பு கூறுகளுடன் வேலை செய்வதற்காகக் கண்டுபிடிக்கப்பட்டன. அவை குறியீடுகளுக்கு (வரைபடம்) பதிலாக பெயர்கள் மட்டுமே இருந்தாலும், அல்லது பெயர்கள் அல்லது குறியீடுகள் இல்லாவிட்டாலும், சேகரிப்பில் உள்ள அனைத்து உறுப்புகளையும் பார்க்க அவை உங்களை அனுமதிக்கின்றன. அமை)."

"இங்கே சில உதாரணங்கள்:"

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() முறை அடுத்த()ஆல் வழங்கப்படாத கூறுகள் இன்னும் உள்ளதா என்பதைச் சரிபார்க்கிறது."

"சரி. இப்போது தெளிவாகிறது என்று நினைக்கிறேன். நான் புரிந்துகொண்டதை மீண்டும் சொல்ல முயற்சிக்கிறேன்."

"எனவே... முதலில், இந்த மேஜிக் இட்ரேட்டர் பொருளைப் பெற, ஒரு சேகரிப்பில் உள்ள இட்டேட்டர்() முறையை நாம் அழைக்க வேண்டும்."

"பின்னர் எஞ்சியுள்ள உறுப்புகள் இருக்கும் வரை ஒவ்வொன்றாகப் பெறுவோம். அடுத்த()ஐ அழைப்பதன் மூலம் சேகரிப்பில் அடுத்த உறுப்பைப் பெறுவோம், மேலும் hasNext()ஐ அழைப்பதன் மூலம் சேகரிப்பில் இன்னும் கூறுகள் உள்ளதா என்பதைச் சரிபார்க்கிறோம். மறு செய்கை. அது சரியா?"

"ஆம், அதிகமாகவோ அல்லது குறைவாகவோ. ஆனால் நல்ல பகுதிக்காக காத்திருங்கள்."

"ஜாவாவில் இட்டேட்டர்களுடன் பணிபுரிவதற்கான சுருக்கெழுத்து குறிப்பீடு உள்ளது. அதே நேரத்தில் மற்றும் க்கு என்ற முறையைப் பின்பற்றி , மேலும் ஒரு சிறப்பு அறிக்கை சேர்க்கப்பட்டுள்ளது: ஒவ்வொன்றிற்கும் . இது முக்கிய சொல்லைப் பயன்படுத்தியும் குறிக்கப்படுகிறது ."

"ஒவ்வொரு அறிக்கையும் சேகரிப்புகள் மற்றும் கொள்கலன்களுடன் பணிபுரிய மட்டுமே பயன்படுத்தப்படுகிறது. இது மறைமுகமாக ஒரு மறு செய்கையைப் பயன்படுத்துகிறது, ஆனால் திரும்பிய உறுப்பை மட்டுமே நாங்கள் பார்க்கிறோம்."

"இடிரேட்டருடன் வேலை செய்வதற்கான நீண்ட மற்றும் சுருக்கெழுத்து வழிகளை நான் உங்களுக்குக் காட்டுகிறேன்:"

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);
    }
}

"இப்போது நீங்கள் பேசுகிறீர்கள்!"

"உங்களுக்கு பிடித்ததில் மகிழ்ச்சி."