படங்களில் வரிசை பட்டியல்

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

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
}

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

ArrayList<Car> cars = new ArrayList<>();
Car ferrari = new Car("Ferrari 360 Spider");
cars.add(ferrari);

இது போதுமானது. நாம் நடுவில் அதாவது மற்ற உறுப்புகளுக்கு இடையில் செருகினால் என்ன நடக்கும்?

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");
   Car ford = new Car("Ford Modneo");
  
   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
  
   cars.add(1, ford);// add ford to cell 1, which is already occupied
}

மீண்டும், முதலில் வரிசையில் போதுமான இடம் உள்ளதா என்பதை சரிபார்க்க வேண்டும். போதுமான இடம் இருந்தால், உறுப்புகள் வலதுபுறமாக மாற்றப்படும் , புதிய உறுப்பைச் செருகும் நிலையில் தொடங்கி. நாங்கள் நிலை 1 இல் செருகுகிறோம். வேறுவிதமாகக் கூறினால், நிலை 3 இலிருந்து உறுப்பு நிலை 4 க்கும், உறுப்பு 2 க்கு நிலை 3 க்கும், உறுப்பு 1 வது நிலை 2 க்கும் நகலெடுக்கப்படும். பின்னர் எங்கள் புதிய உறுப்பு அதன் இடத்தில் செருகப்படும். முந்தைய உறுப்பு (புகாட்டி) ஏற்கனவே அங்கிருந்து ஒரு புதிய நிலைக்கு நகலெடுக்கப்பட்டது. அணிவரிசையில் புதிய கூறுகளைச் செருகுவதற்கு இடங்கள் இல்லை என்றால், இந்த செயல்முறை எவ்வாறு நிகழ்கிறது என்பதை இப்போது பார்க்கலாம். இயற்கையாகவே, போதுமான இடம் இருக்கிறதா என்பதை முதலில் சரிபார்க்க வேண்டும். போதுமான இடம் இல்லை என்றால், உள்ளே ஒரு புதிய வரிசை உருவாக்கப்படும்ArrayListயாருடைய அளவு என்பது பழைய வரிசை முறைகளின் அளவு 1.5 மற்றும் 1 ஆகும், எங்கள் விஷயத்தில், புதிய அணிவரிசையின் அளவு 16 ஆக இருக்கும். தற்போதைய உறுப்புகள் அனைத்தும் உடனடியாக நகலெடுக்கப்படும். பழைய வரிசை குப்பை சேகரிப்பாளரால் நீக்கப்படும், மேலும் புதிய, விரிவாக்கப்பட்ட வரிசை மட்டுமே இருக்கும். இப்போது ஒரு புதிய உறுப்புக்கான இடம் உள்ளது. நாங்கள் அதை ஆக்கிரமிக்கப்பட்ட நிலையில் 3 இல் செருகுகிறோம். இப்போது பழக்கமான செயல்முறை தொடங்குகிறது. அனைத்து உறுப்புகளும், குறியீட்டு 3 இல் தொடங்கி, ஒரு நிலையில் வலதுபுறமாக மாற்றப்பட்டு, புதிய உறுப்பு அமைதியாக சேர்க்கப்படுகிறது. மற்றும் செருகல் முடிந்தது! நாங்கள் செருகுவதை முடித்துவிட்டோம். இப்போது பொருட்களை அகற்றுவது பற்றி பேசலாம் . வரிசைகளுடன் பணிபுரியும் போது நாங்கள் ஒரு சிக்கலை எதிர்கொண்டோம் என்பதை நீங்கள் நினைவில் வைத்திருப்பீர்கள்: உறுப்புகளை அகற்றுவது ஒரு வரிசையில் "துளைகளை" உருவாக்குகிறது.ஒவ்வொரு அகற்றுதலின் போதும், இந்த மாற்றத்தைச் செய்ய ஒவ்வொரு முறையும் எங்கள் சொந்த குறியீட்டை எழுத வேண்டும். ArrayList அதே கொள்கையைப் பின்பற்றுகிறது, ஆனால் இது ஏற்கனவே இந்த பொறிமுறையை செயல்படுத்துகிறது. இது இப்படித்தான் தெரிகிறது: இறுதியில் நாம் விரும்புவதைப் பெறுகிறோம்: உறுப்பு lamboஅகற்றப்பட்டது. இங்கே நாம் நடுவில் இருந்து ஒரு உறுப்பை அகற்றினோம். தெளிவாக, பட்டியலின் முடிவில் இருந்து ஒரு உறுப்பை அகற்றுவது வேகமானது, ஏனென்றால் மற்ற அனைத்தையும் மாற்ற வேண்டிய அவசியமின்றி உறுப்பு வெறுமனே அகற்றப்படும். உள் வரிசையின் பரிமாணங்கள் மற்றும் நினைவகத்தில் அது எவ்வாறு அமைக்கப்பட்டிருக்கிறது என்பதைப் பற்றி மீண்டும் ஒரு கணம் பேசுவோம். ஒரு வரிசையை விரிவாக்குவதற்கு சில ஆதாரங்கள் தேவைப்படும். அதன்படி, ஒரு உருவாக்க வேண்டாம்ArrayListகுறைந்தது 100 உறுப்புகள் இருக்கும் என்று நீங்கள் உறுதியாக நம்பினால், இயல்புநிலை அளவுடன். நீங்கள் 100 வது உறுப்பைச் செருகும் நேரத்தில் உள் அணி 6 முறை விரிவாக்கப்பட வேண்டும் , மேலும் ஒவ்வொரு முறையும் அனைத்து உறுப்புகளும் மாற்றப்பட வேண்டும்.

• 10 உறுப்புகளிலிருந்து 16 வரை
• 16 உறுப்புகளிலிருந்து 25 வரை
• 25 முதல் 38 வரை
• 38 முதல் 58 வரை
• 58 முதல் 88 வரை
• 88 முதல் 133 வரை (அதாவது பழைய வரிசையின் அளவு 1.5 கூட்டல் 1)

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

ArrayList<Car> cars = new ArrayList<>(100);

இப்போது 100 தனிமங்களின் வரிசைக்கான நினைவகம் ஒரே நேரத்தில் ஒதுக்கப்படும், இது வரிசையை மிகவும் திறமையாக்குகிறது (அதை விரிவாக்க வேண்டிய அவசியமில்லை). இந்த மூலோபாயம் ஒரு மறுபக்கத்தையும் கொண்டுள்ளது. ஒரு இலிருந்து பொருட்களை அகற்றும் போது ArrayList, ​​உள் வரிசையின் அளவு தானாகவே குறையாது. எங்களிடம் ArrayList88 உறுப்புகளின் முழுமையான உள் வரிசை உள்ளது என்று வைத்துக்கொள்வோம்: நிரல் இயங்கும் போது, ​​77 உறுப்புகளை அகற்றுவோம், அதனால் 11 மட்டுமே எஞ்சியுள்ளது: பிரச்சனை என்னவென்று நீங்கள் ஏற்கனவே யூகித்திருக்கிறீர்களா? உங்களுக்கு புரிந்தது, நினைவாற்றலின் திறமையற்ற பயன்பாடு! நாங்கள் இங்கு 11 நிலைகளை மட்டுமே பயன்படுத்துகிறோம், ஆனால் 88 உறுப்புகளுக்கு நினைவகத்தை ஒதுக்கியுள்ளோம். இது நமக்கு தேவையானதை விட 8 மடங்கு அதிகம்! ArrayListஇந்த வழக்கில், வகுப்பின் சிறப்பு முறைகளில் ஒன்றைக் கொண்டு நமது நினைவகப் பயன்பாட்டை மேம்படுத்தலாம் :trimToSize(). இந்த முறையானது உள் வரிசையின் நீளத்தை அதில் தற்போது சேமித்து வைக்கப்பட்டுள்ள உறுப்புகளின் எண்ணிக்கைக்கு "டிரிம்" செய்கிறது. இப்போது நமக்கு தேவையான அளவு நினைவகத்தை மட்டுமே ஒதுக்கியுள்ளோம்! :)