ArrayList உடன் பணிபுரிகிறது

1. எப்படி ArrayListகட்டமைக்கப்பட்டுள்ளது

ArrayListஉறுப்புகளை சேமிப்பதற்கு பொதுவாக பயன்படுத்தப்படும் ஜாவா வகுப்பு. எனவே எப்படி ArrayListவேலை செய்கிறது மற்றும் ஏன் எல்லோரும் அதை மிகவும் விரும்புகிறார்கள்?

அமைப்பு ArrayListஎளிமையானது மற்றும் புத்திசாலித்தனமானது. ஒவ்வொரு ArrayListபொருளும் இரண்டு புலங்களைக் கொண்டுள்ளது:

• உறுப்புகளின் வரிசை
• ஒரு sizeமாறி, இது பட்டியலில் உள்ள உறுப்புகளின் எண்ணிக்கையை சேமிக்கிறது

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

ஆரம்பத்தில், பட்டியலுக்குள் இருக்கும் வரிசையின் நீளம் 10. மற்றும் மாறி size0.

பட்டியலில் ஒரு உறுப்பைச் சேர்த்தால், அது வரிசையின் 0வது கலத்தில் சேமிக்கப்படும், மேலும் size1 ஆக அதிகரிக்கும்.

நீங்கள் இன்னும் ஒரு உறுப்பைச் சேர்த்தால், அது 1 வது கலத்தில் சேமிக்கப்படும், மேலும் sizeமீண்டும் 1 ஆல் அதிகரித்து இரண்டாக மாறும்.

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

1. முந்தையதை விட ஒன்றரை மடங்கு நீளம் கொண்ட புதிய வரிசை உருவாக்கப்பட்டது
2. பழைய வரிசையின் அனைத்து கூறுகளும் புதிய வரிசையில் நகலெடுக்கப்படுகின்றன.
3. பொருளில் ArrayList, புதிய வரிசைக்கான குறிப்பு பழையதைக் குறிக்கும் .
4. அனுப்பப்பட்ட உறுப்பு புதிய அணிவரிசையின் 10வது கலத்தில் சேமிக்கப்படுகிறது .
5. அளவு மாறி 1 ஆல் அதிகரிக்கிறது மற்றும் இப்போது 11 க்கு சமமாக இருக்கும்

பட்டியலின் நடுவில் ஒரு உறுப்பைச் சேர்க்கும்போது (செருகும்போது) இதேபோன்ற ஒன்று நடக்கும். ஏற்கனவே உள்ள உறுப்புகள் 1 ஆல் வலப்புறமாக மாற்றப்பட்டு, அனுப்பப்பட்ட உறுப்பு வரிசையின் புதிதாக விடுவிக்கப்பட்ட கலத்தில் எழுதப்படும்.

இப்போது பட்டியல்களை உள்ளடக்கிய மிக அடிப்படையான காட்சிகளைக் கருத்தில் கொள்வோம்:

2. ஒரு உறுப்பை ஒரு உடன் சேர்த்தல்ArrayList

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

எங்களிடம் ArrayListஇரண்டு புலங்களைக் கொண்ட ஒரு பொருள் உள்ளது (இரண்டு மாறிகள்): ஒரு கொள்கலன் (வரிசை data) மற்றும் சேமிக்கப்பட்ட உறுப்புகளின் எண்ணிக்கை ( size). மாறி data10 கூறுகளை சேமிக்கக்கூடிய ஒரு கொள்கலன் (வரிசை) பற்றிய குறிப்பை சேமிக்கிறது.

வரிசையில் எண் 5 ஐ சேர்க்க முடிவு செய்தால், பின்வரும் படத்தைப் பெறுவோம்:

வரிசை இப்போது உறுப்பு 5 மற்றும் size == 1.

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

தற்போதைய சேமிப்பகத் திறனோ அல்லது அணிவரிசையோ பொருளுக்கு வெளியே எப்போதும் அணுக முடியாது (தெரியும்) ArrayList. இது எப்போதும் இன் ArrayListஉள் தரவாக இருக்கும்.

பட்டியலில் மேலும் 7 எண்களைச் சேர்ப்போம்: 10, 20, 30, 40, 50, 60, 70.

இப்போது நினைவகம் இப்படி இருக்கும்:

நீங்கள் இப்போது முறையை அழைத்தால் size(), அது பட்டியலில் உள்ள புதிய உறுப்புகளின் எண்ணிக்கையான 8 என்ற எண்ணை வழங்கும். இந்த மதிப்புக்கு உள் வரிசையின் அளவோடு எந்த தொடர்பும் இல்லை.

3. பட்டியலின் நீளத்தை அதிகரித்தல்

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

எங்களிடம் 10 கூறுகளின் பட்டியல் உள்ளது என்று வைத்துக்கொள்வோம்:

அதில் 100 என்ற எண்ணைச் சேர்க்க முடிவு செய்கிறோம் . இந்த முறையில் நடப்பது இதுதான் add():

படி 1 - புதிய வரிசையை உருவாக்கவும்:

படி 2 - பழைய அணிவரிசையிலிருந்து புதிய ஒன்றுக்கு அனைத்து கூறுகளையும் நகலெடுக்கவும்:

படி 3 — பழைய வரிசையை மாற்றவும் (பொருளின் உள் வரிசைக்கான குறிப்பை மாற்றவும் ArrayList):

படி 4 - புதிய எண்ணைச் சேர்க்கவும், அதைச் செய்ய நாங்கள் கடினமாக உழைத்தோம்: