தொகுப்புகள் மற்றும் வரிசைப்பட்டியல்

ஜாவாவில் உள்ள பாரம்பரிய வரிசைகள் உருவாக்கத்தின் போது வரையறுக்கப்பட்ட ஒரு நிலையான அளவைக் கொண்டுள்ளன. அளவு மாறக்கூடிய தரவுகளின் பட்டியல்களுடன் பணிபுரிய, Java Java Collections Frameworkஐ வழங்குகிறது. பொதுவாகப் பயன்படுத்தப்படும் வகுப்பு ArrayList.

ArrayList வகுப்பு மற்றும் பொதுவானவை

ArrayList நினைவகத்தில் மறுஅளவிடக்கூடிய வரிசையை செயல்படுத்துகிறது. ArrayListஐ அறிவிக்க, < > கோண அடைப்புக்குறிக்குள் அடைப்பதன் மூலம் அதில் உள்ள உறுப்புகளின் வகையைக் குறிப்பிட வேண்டும். இந்த அம்சம் ஜெனரிக்ஸ் என்று அழைக்கப்படுகிறது.

ArrayList ஐப் பயன்படுத்த, கோப்பின் தொடக்கத்தில் java.util.ArrayList இலிருந்து இறக்குமதி செய்ய வேண்டும்.

அறிவிப்பு மற்றும் உடனடி அறிவிப்பு:

import java.util.ArrayList;

ArrayList<String> shoppingList = new ArrayList<>();

முக்கிய முறைகள்

ArrayList இன் அடிப்படை செயல்பாடுகள் இதோ:

1. add(element): பட்டியலின் முடிவில் ஒரு உறுப்பைச் சேர்க்கிறது.
2. get(index): குறிப்பிட்ட குறியீட்டில் (0-இண்டெக்ஸ்) உறுப்பை வழங்கும்.
3. size(): பட்டியலில் தற்போது உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது.
4. remove(index): குறிப்பிட்ட குறியீட்டில் உள்ள உறுப்பை நீக்குகிறது.

shoppingList.add("Pane");
shoppingList.add("Latte");

System.out.println("Elementi: " + shoppingList.size()); // Prints 2
System.out.println("Primo elemento: " + shoppingList.get(0)); // Prints "Pane"

ஒரு பட்டியலின் மீது மீண்டும் மீண்டும் (ஒவ்வொருவருக்கும்)

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

for (String item : shoppingList) {
    System.out.println(item);
}

வரிசை vs வரிசை பட்டியல்: நினைவகம் மற்றும் செயல்திறன்

நிலையான வரிசையை விட ArrayList மிகவும் நெகிழ்வானதாக இருந்தாலும், இது செயல்திறன் மற்றும் நினைவக பரிமாற்றங்களுடன் வருகிறது:

• ** நிலையான வரிசை**: இது நினைவகத்தின் தொடர்ச்சியான தொகுதியில் ஒதுக்கப்பட்டுள்ளது, நிலையான அளவைக் கொண்டுள்ளது மற்றும் குறியீட்டு வழியாக உறுப்புகளை அணுகுவது மிக வேகமாக இருக்கும். இது பழமையான வகைகளை நேரடியாக மேல்நிலை இல்லாமல் சேமிக்கிறது.
• அரேலிஸ்ட்: உள்நாட்டில், அதன் ஆரம்பத் திறனை (பொதுவாக 10) மீறும் போது, ​​மறுஅளவிடப்படும் (புதிய பெரிய வரிசையை உருவாக்கி பழைய கூறுகளை நகலெடுப்பதன் மூலம்) இது ஒரு வரிசையை நிர்வகிக்கிறது. மேலும், இது பொருள் குறிப்புகளை மட்டுமே சேமிக்கிறது, ஒவ்வொரு உறுப்புக்கும் நினைவக மேல்நிலையை அறிமுகப்படுத்துகிறது.

ஆட்டோ பாக்ஸிங் மற்றும் அன்பாக்சிங்

ArrayList பொருள்களை மட்டுமே வைத்திருக்க முடியும் என்பதால், ஜாவா தானாகவே பழமையான வகைகளுக்கும் அவற்றின் ரேப்பர் வகுப்புகளுக்கும் இடையில் மாற்றங்களைச் செய்கிறது:

• ஆட்டோ பாக்ஸிங்: ஒரு பழமையான வகையிலிருந்து ரேப்பர் வகுப்பிற்கு தானியங்கி மாற்றம். எடுத்துக்காட்டாக, நீங்கள் numbers.add(42) என்று எழுதும்போது, ​​Java தானாகவே 42 (int) ஐ Integer.valueOf(42) (முழு எண்) ஆக மாற்றுகிறது.
• அன்பாக்சிங்: ரேப்பர் வகுப்பிலிருந்து ஒரு பழமையான வகைக்கு தானியங்கு மாற்றம். எடுத்துக்காட்டாக, நீங்கள் int num = numbers.get(0) ஐ இயக்கும்போது, ​​Java உள்நாட்டில் Integer ஐ int ஆக மாற்றுகிறது.

நீங்களே முயற்சி செய்து பாருங்கள்