வரிசைப்பட்டியலில் இருந்து ஒரு உறுப்பை நீக்குகிறது

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

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

       System.out.println(Arrays.toString(cats));
   }

   
@Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

வெளியீடு: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] ஆனால் வரிசை உறுப்பை பூஜ்யமாக அமைப்பது ஒரு "துளையை" விட்டுவிடும். வரிசையில் உள்ள நிலையை நாங்கள் அகற்றவில்லை, அதன் உள்ளடக்கங்களை மட்டுமே. 50 பூனைகள் வரிசையாக இருந்தால், அவற்றில் 17 பூனைகளை இந்த வழியில் அகற்றினால் என்ன நடக்கும் என்று கற்பனை செய்து பாருங்கள். எங்களிடம் 17 துளைகள் கொண்ட ஒரு வரிசை இருக்கும். அவற்றைக் கண்காணிக்க முயற்சிக்கவும்! நீங்கள் புதிய மதிப்புகளை எழுதக்கூடிய வெற்று கலங்களின் எண்ணிக்கையை நினைவில் வைத்திருப்பது நம்பத்தகாதது. நீங்கள் ஒரு தவறு செய்தால், நீங்கள் விரும்பும் ஒரு பொருள் குறிப்பை மேலெழுதுவீர்கள். நிச்சயமாக, இதை இன்னும் கொஞ்சம் கவனமாகச் செய்ய ஒரு வழி உள்ளது: ஒரு உறுப்பை அகற்றிய பிறகு, "துளை"யை இறுதியில் வைக்க உறுப்புகளை வரிசையின் முன்புறத்திற்கு நகர்த்தவும் :

public static void main(String[] args) {

   Cat[] cats = new Cat[4];
   cats[0] = new Cat("Thomas");
   cats[1] = new Cat("Behemoth");
   cats[2] = new Cat("Lionel Messi");
   cats[2] = new Cat("Fluffy");

   cats[1] = null;

   for (int i = 2; i < cats.length-1; i++) {
       cats [i-1] = cats [i];// Move the elements to the front of the array, so the empty position is at the end
   }

   System.out.println(Arrays.toString(cats));
}

வெளியீடு: [பூனை{பெயர்='தாமஸ்'}, பூனை{பெயர்='பஞ்சுபோன்ற'}, பூனை{பெயர்='பஞ்சுபோன்ற'}, பூஜ்யம்] இது சிறப்பாகத் தெரிகிறது, ஆனால் இது ஒரு வலுவான தீர்வு என்று அழைக்கப்பட முடியாது. ஒவ்வொரு முறையும் ஒரு வரிசையிலிருந்து ஒரு உறுப்பை நீக்கும் போது இந்தக் குறியீட்டை எழுத வேண்டும் என்பது வேறு எந்த காரணத்திற்காகவும் இல்லை என்றால்! இது ஒரு மோசமான விருப்பம். நாம் வேறு வழியில் சென்று ஒரு தனி முறையை உருவாக்கலாம்:

public void deleteCat(Cat[] cats, int indexToDelete) {
   //...delete the cat corresponding to the index and move the elements
}

ஆனால் இதுவும் சிறிய பயன்: இந்த முறை பொருள்களுடன் மட்டுமே வேலை செய்ய முடியும் Cat, ஆனால் மற்ற வகைகளில் அல்ல. வேறு வார்த்தைகளில் கூறுவதானால், ஒரு நிரலில் அணிவரிசைகளுடன் பயன்படுத்த விரும்பும் மற்றொரு 100 வகுப்புகள் இருந்தால், அவை ஒவ்வொன்றிலும் ஒரே மாதிரியான தர்க்கத்துடன் அதே முறையை எழுத வேண்டும். இது மொத்த பேரழிவு -_- ஆனால் ArrayListவர்க்கம் இந்த சிக்கலை தீர்க்கிறது! உறுப்புகளை அகற்ற இது ஒரு சிறப்பு முறையை செயல்படுத்துகிறது:remove()

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);
   System.out.println(cats.toString());

   cats.remove(1);

   System.out.println(cats.toString());
}

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

[Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]

[Cat{name='Thomas'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]

நாங்கள் ஒரு பூனையை நடுவில் இருந்து அகற்றினோம், மீதமுள்ளவை வெற்று இடங்கள் இல்லாதபடி நகர்த்தப்பட்டன. இரண்டாவதாக , இது பொருள்களை குறியீட்டால் மட்டும் நீக்க முடியும் (சாதாரண வரிசை போன்றது), ஆனால் குறிப்பு :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);
   System.out.println(cats.toString());

   cats.remove(lionel);

   System.out.println(cats.toString());
}

வெளியீடு: [பூனை{பெயர்='தாமஸ்'}, பூனை{பெயர்='பெஹெமோத்'}, பூனை{பெயர்='லியோனல் மெஸ்ஸி'}, பூனை{பெயர்='பஞ்சுபோன்ற'}] [பூனை{பெயர்='தாமஸ்'}, Cat{name='Behemoth'}, Cat{name='Fluffy'}] நீங்கள் விரும்பும் பொருளின் குறியீட்டை எப்போதும் கண்காணிக்க விரும்பவில்லை என்றால் இது மிகவும் வசதியாக இருக்கும். சாதாரண நீக்குதலைக் கண்டுபிடித்துவிட்டதாகத் தெரிகிறது. இப்போது இந்த சூழ்நிலையை கற்பனை செய்வோம்: எங்கள் பட்டியலை மீண்டும் மீண்டும் செய்ய விரும்புகிறோம் மற்றும் ஒரு குறிப்பிட்ட பெயரைக் கொண்ட பூனையை அகற்ற வேண்டும் . forஇதைச் செய்ய, ரிஷியின் பாடங்களில் எங்களுக்கு அறிமுகப்படுத்தப்பட்ட வேகமான வளையத்தைப் பயன்படுத்துவோம் (ஒவ்வொரு லூப் என்றும் அழைக்கப்படுகிறது).

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   for (Cat cat: cats) {

       if (cat.name.equals("Behemoth")) {
           cats.remove(cat);
       }
   }

   System.out.println(cats);
}

குறியீடு முற்றிலும் தர்க்கரீதியாகத் தெரிகிறது. ஆனால் முடிவு ஒரு பெரிய ஆச்சரியமாக இருக்கலாம்: நூல் "முதன்மை" java.util இல் விதிவிலக்கு java:831) Cat.main இல்(Cat.java:25) ஒருவித பிழை உள்ளது, அது ஏன் ஏற்பட்டது என்பது தெளிவாகத் தெரியவில்லை. இந்த செயல்முறை கவனிக்கப்பட வேண்டிய பல நுணுக்கங்களை உள்ளடக்கியது. நீங்கள் நினைவில் கொள்ள வேண்டிய பொதுவான விதி இங்கே உள்ளது: நீங்கள் ஒரு தொகுப்பை ஒரே நேரத்தில் மீண்டும் செய்ய முடியாது மற்றும் அதன் கூறுகளை மாற்ற முடியாது. மேலும் நாங்கள் எந்த வகையான மாற்றத்தையும் குறிக்கிறோம், வெறுமனே அகற்றுவது அல்ல. புதிய பூனைகளைச் செருகும் முயற்சியுடன் பூனை அகற்றுதலை மாற்றினால், விளைவு ஒரே மாதிரியாக இருக்கும்:

for (Cat cat: cats) {

   cats.add(new Cat("Salem Saberhagen"));
}

System.out.println(cats);

நூல் "முதன்மை" java.util இல் விதிவிலக்கு Cat.java:25) ஒரு செயலை மற்றொன்றுக்கு மாற்றினோம், ஆனால் முடிவு மாறவில்லை: அதே ConcurrentModificationException . மேலே உள்ள விதியை மீற முயற்சிக்கும் போது, ​​பட்டியலை மாற்றியமைக்கும்போது அது துல்லியமாக நிகழ்கிறது. ஜாவாவில்,ஒரு சேகரிப்பில் மீண்டும் மீண்டும் செய்யும் போது உருப்படிகளை நீக்க, நமக்கு இடிரேட்டர் (உறுப்புகளின் பட்டியலைப் பாதுகாப்பாகச் செயல்படுத்துவதற்கு வர்க்கம் பொறுப்பாகும்Iterator. Iteratorஇது மிகவும் எளிமையானது, ஏனெனில் இதற்கு 3 முறைகள் மட்டுமே உள்ளன:

• hasNext()- பட்டியலில் அடுத்த உருப்படி உள்ளதா அல்லது நாங்கள் ஏற்கனவே கடைசி உருப்படியை அடைந்துவிட்டோமா என்பதைப் பொறுத்து சரி அல்லது தவறு என்பதை வழங்குகிறது.
• next()- பட்டியலில் உள்ள அடுத்த உருப்படியை வழங்குகிறது
• remove()- பட்டியலிலிருந்து ஒரு உருப்படியை நீக்குகிறது

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

Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list
  
   Cat nextCat = catIterator.next();// Get the next element
   System.out.println(nextCat);// Display it
}

வெளியீடு: Cat{name='Thomas'} Cat{name='Behemoth'} Cat{name='Lionel Messi'} Cat{name='Fluffy'} நீங்கள் பார்க்க முடியும் என, ஏற்கனவே ஒரு ArrayListசிறப்பு முறையை உருவாக்கி செயல்படுத்தியுள்ளது மீண்டும் செய்பவர்: iterator(). கூடுதலாக, நாம் ஒரு இட்டேட்டரை உருவாக்கும்போது, ​​அது ( ) உடன் வேலை செய்யும் பொருட்களின் வகுப்பைக் குறிப்பிடுகிறோம் <Cat>. இதன் முக்கிய அம்சம் என்னவென்றால், ஒரு இட்டேட்டர் நமது அசல் பணியை எளிதில் கையாளுகிறது. எடுத்துக்காட்டாக, "லியோனல் மெஸ்ஸி" என்ற பூனையை அகற்றவும்:

Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list

   Cat nextCat = catIterator.next();// Get the next element
   if (nextCat.name.equals("Lionel Messi")) {
       catIterator.remove();// Delete the cat with the specified name
   }
}

System.out.println(cats);

வெளியீடு: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Fluffy'}]remove() இட்ரேட்டரின் முறையில் குறியீட்டையோ பெயரையோ நாங்கள் குறிப்பிடவில்லை என்பதை நீங்கள் கவனித்திருக்கலாம். ! மறு செய்கையானது தோன்றக்கூடியதை விட புத்திசாலித்தனமானது: remove()மறு செய்கையால் வழங்கப்பட்ட கடைசி உறுப்பை நீக்குகிறது. நீங்கள் பார்க்க முடியும் என, நாங்கள் எதைச் செய்ய விரும்புகிறோமோ அதைத்தான் அது செய்தது :) கொள்கையளவில், ஒரு இலிருந்து உறுப்புகளை அகற்றுவது பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டியது இதுதான் ArrayList. சரி, கிட்டத்தட்ட எல்லாம். அடுத்த பாடத்தில், இந்த வகுப்பிற்குள் பார்ப்போம், பல்வேறு முறை அழைப்புகளின் போது அங்கு என்ன நடக்கிறது என்று பார்ப்போம் :) அதுவரை!