"ஹாய், அமிகோ!"
"ஹாய், எல்லி!"
"இன்று நாங்கள் சேகரிப்புகளின் கட்டமைப்பை ஒருமுறை மற்றும் அனைவருக்கும் சுற்றி வருவோம்."
"நான் இதற்காக நீண்ட நேரம் காத்திருந்தேன்."
"சேகரிப்புகள் என்னவென்று உங்களுக்கு ஏற்கனவே தெரியும், அவற்றுடன் எவ்வாறு வேலை செய்வது என்பது உங்களுக்குத் தெரியும். உங்கள் அறிவை ஒரு கண்டிப்பான அமைப்பாக ஒழுங்கமைக்க வேண்டிய நேரம் இது. பிறகு பல 'ஏன்' மற்றும் 'எப்படி' கேள்விகள் மறைந்துவிடும், மேலும் பெரும்பாலான விஷயங்கள் தெளிவாகிவிடும்."
" சேகரிப்பு இடைமுகங்கள் . சேகரிப்பு இடைமுகங்களின் பரம்பரை அமைப்பு இது போல் தெரிகிறது:"
இரண்டு விஷயங்களைக் கவனியுங்கள்.
முதலில், நீங்கள் இங்கு பார்க்கும் அனைத்தும் ஒரு இடைமுகம்.
இரண்டாவதாக, அம்புகள் "பரம்பரை" என்று பொருள்.
"வேறு வார்த்தைகளில் கூறுவதானால், பட்டியல், அமை மற்றும் வரிசை ஆகியவை சேகரிப்பைப் பெறுகின்றன, ஆனால் வரைபடம் பெறவில்லையா?"
"ஆம். சுருக்க வகுப்புகள் இந்த இடைமுகங்களைப் பெறுகின்றன, அதையொட்டி, சுருக்க வகுப்புகளைப் பற்றி உங்களுக்குத் தெரிந்த செயலாக்கங்கள் பெறுகின்றன: ArrayList, Hashtable, TreeSet,... "
"நீங்கள் சொல்வது சரிதான்."
"இப்போது இந்த இடைமுகங்களின் முறைகள் எதற்காக என்று பார்ப்போம்:"
மறுசெலுத்தக்கூடிய முறைகள் <E>: இடைமுகம்:
| முறைகள் | விளக்கம் |
|---|---|
Iterator<T> iterator(); |
ஒரு இடிரேட்டர் பொருளை வழங்குகிறது. |
"அது போதுமானதாகத் தெரியவில்லை."
"சரி, அதுதான் எத்தனை இருக்கிறது. திரும்பத் திரும்பச் செய்பவர்களுக்கு அவ்வளவுதான். நாங்கள் இப்போது அவற்றை மறைக்க மாட்டோம், ஆனால் விரைவில் அவற்றை விரிவாகக் கூறுவோம்."
சேகரிப்பு முறைகள் <E>: இடைமுகம்:
| முறைகள் | விளக்கம் |
|---|---|
boolean add(E e); |
சேகரிப்பில் ஒரு உறுப்பைச் சேர்க்கிறது |
boolean addAll(Collection<? extends E> c); |
சேகரிப்பில் கூறுகளைச் சேர்க்கிறது |
void clear(); |
சேகரிப்பிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது |
boolean contains(Object o); |
சேகரிப்பில் உறுப்பு உள்ளதா என சரிபார்க்கிறது. |
boolean containsAll(Collection<?> c); |
சேகரிப்பில் கூறுகள் உள்ளதா என சரிபார்க்கிறது. |
boolean equals(Object o); |
சேகரிப்புகள் சமமாக உள்ளதா என்பதைப் பார்க்கவும் |
int hashCode(); |
ஹாஷ் குறியீட்டை வழங்கும் |
boolean isEmpty(); |
சேகரிப்பு காலியாக உள்ளதா என சரிபார்க்கிறது. |
Iterator<E> iterator(); |
ஒரு இடிரேட்டர் பொருளை வழங்குகிறது |
boolean remove(Object o); |
சேகரிப்பிலிருந்து ஒரு உறுப்பை நீக்குகிறது |
boolean removeAll(Collection<?> c); |
சேகரிப்பிலிருந்து கூறுகளை நீக்குகிறது |
boolean retainAll(Collection<?> c); |
c இல் இல்லாத அனைத்து கூறுகளையும் நீக்குகிறது |
int size(); |
சேகரிப்பின் அளவை வழங்குகிறது |
Object[] toArray(); |
தொகுப்பை அணிவரிசையாக மாற்றுகிறது |
<T> T[] toArray(T[] a); |
தொகுப்பை அணிவரிசையாக மாற்றுகிறது |
"நான் ஏற்கனவே இங்கே எல்லாவற்றிலும் உறுதியாக இருக்கிறேன். இந்த முறைகளில் பாதியைப் பயன்படுத்தினேன், மற்ற பாதியை நான் சந்தித்தேன்."
"அருமை, பிறகு தொடரலாம்."
பட்டியலின் முறைகள் <E>: இடைமுகம்:
| முறைகள் | விளக்கம் |
|---|---|
void add(int index, E element); |
சேகரிப்பின் நடுவில் கூறுகளைச் சேர்க்கிறது |
boolean addAll(int index, Collection<? extends E> c); |
சேகரிப்பில் கூறுகளைச் சேர்க்கிறது |
E get(int index); |
குறியீட்டின் அடிப்படையில் ஒரு உறுப்பை வழங்கும் |
int indexOf(Object o); |
ஒரு தனிமத்தின் குறியீட்டை (எண்) வழங்கும் |
int lastIndexOf(Object o); |
கடைசி உறுப்பின் குறியீட்டை வழங்கும். |
ListIterator<E> listIterator(); |
பட்டியலுக்கான மறு செய்கையை வழங்கும் |
ListIterator<E> listIterator(int index); |
பட்டியலுக்கான மறு செய்கையை வழங்கும் |
E remove(int index); |
ஒரு உறுப்பை அதன் குறியீட்டின் மூலம் நீக்குகிறது |
E set(int index, E element); |
குறியீட்டின்படி புதிய மதிப்பை அமைக்கிறது |
List<E> subList(int fromIndex, int toIndex); |
துணைத் தொகுப்பை வழங்குகிறது |
"இங்கேயும் புதிதாக எதுவும் இல்லை. சேகரிப்புகளைப் பற்றி எனக்கு ஏற்கனவே எல்லாமே தெரியும், அதைப்பற்றி என்னால் மகிழ்ச்சியாக இருக்க முடியாது."
"சரி, உங்களை ஆச்சரியப்படுத்தும் ஒன்றை என்னால் கண்டுபிடிக்க முடியும் என்று நினைக்கிறேன். ஆனால் இடைமுகங்களைத் தொடர்ந்து ஆய்வு செய்வோம்:"
தொகுப்பின் முறைகள் <E>: இடைமுகம்:
| முறைகள் | விளக்கம் |
|---|---|
|
|
|
"செட் இடைமுகத்தில் புதிய முறைகள் எதுவும் இல்லை - அது மரபுரிமையாக மட்டுமே உள்ளது."
"ஆமாம், இண்டரபிள் இடைமுகத்திலும் எதுவும் இல்லை என்று பார்த்தேன்.
"மறுபுறம், குறைவான முறைகள் நினைவில் கொள்வது குறைவு!"
"உங்கள் வாழ்க்கையை உறுதிப்படுத்தும் நம்பிக்கை எனக்கு மகிழ்ச்சி அளிக்கிறது."
"அமைவு இடைமுகம் இரண்டு இடைமுகங்கள் மூலம் பெறப்படுகிறது: SortedSet மற்றும் NavigableSet. ஆனால் நான் அவற்றைக் கடந்து செல்லமாட்டேன் அல்லது நாங்கள் முடிக்க மாட்டோம்."
"மாறாக, ஜாவாவில் சேகரிப்புகளை விவரிக்கும் வகுப்புகள் மற்றும் இடைமுகங்களின் பொதுவான படத்தை உங்களுக்கு தருகிறேன்."
"கொண்டு வா."
"அப்படியானால் இறுக்கமாகப் பிடித்துக்கொள்:"
"ஆஹா, அது மிகப்பெரியது!"
"சரி, அது பெரிதாக இல்லை. மேலும், சுருக்க வகுப்புகள் முற்றிலும் விருப்பமானவை என்பதை நினைவில் கொள்ளுங்கள். ஆனால் எந்த வகுப்பு எந்த இடைமுகங்களைச் செயல்படுத்துகிறது என்பதை நினைவில் கொள்வது நல்லது. அது அடிக்கடி கைக்கு வரும்."
"ஓ, சில சேகரிப்புகள் வழக்கற்றுப் போனதாகக் கருதப்படுவதையும் நான் கவனிக்க விரும்புகிறேன்."
"அவை எவை?"
"நான் வெக்டர், ஸ்டாக், அகராதி மற்றும் ஹேஷ்டேபிள் வகுப்புகளைப் பற்றி பேசுகிறேன். இவை சாதாரண சேகரிப்புகளின் ஒத்திசைக்கப்பட்ட (த்ரெட்-பாதுகாப்பான) பதிப்புகள்."
"ஆனால் ஜாவா ஒரு சிறப்பு ஒத்திசைவு நூலகத்தைச் சேர்த்துள்ளது, இது மற்ற த்ரெட்களில் இருந்து அணுகக்கூடியது மட்டுமல்லாமல், மிகவும் திறமையான செயலாக்கத்தையும் கொண்டுள்ளது. ஹேஷ்டேபிளை விட ConcurrentHashMap மிகவும் திறமையானது ."
"நீங்கள் வெக்டார், ஸ்டாக், அகராதி மற்றும் ஹேஸ்டேபிள் தொகுப்புகளைப் பயன்படுத்தலாம், ஆனால் அது பரிந்துரைக்கப்படவில்லை."
"புரிகிறது, நான் அதை மனதில் வைத்துக்கொள்கிறேன்."
"நன்றி, எல்லி!"
GO TO FULL VERSION