ஜாவாவில் சேகரிப்புகள்: வரிசைப்பட்டியல்

1. ArrayListவர்க்கம்

இன்று நாம் வகுப்பை ஆராய்வோம் ArrayList. சேகரிப்புகள் எனப்படும் பல வகுப்புகளில் இதுவே முதன்மையானது . ஜாவாவில், சேகரிப்புகள் மிகவும் பரந்த மற்றும் பயனுள்ள தலைப்பாகும், முழு CodeGym தேடலும் அவர்களுக்கு அர்ப்பணிக்கப்பட்டுள்ளது.

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

எனவே இன்று நாம் எளிய வகையான சேகரிப்புடன் பழகுவோம். ஆனால் போதுமான ஆழமான மட்டத்தில், அதை எவ்வாறு பயன்படுத்துவது மற்றும் அது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வீர்கள். இப்போது, ArrayList​​சேகரிப்பை சந்திக்கவும் .

பின்கதை

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

நீங்கள் சேமித்து வைக்க வேண்டிய அனைத்து கூறுகளுக்கும் இடமளிக்கும் வகையில் மிகப் பெரிய வரிசையை உருவாக்குவதே ஒரு வரிசையின் இட வரம்புகளுக்கு ஒரே தீர்வு. ஆனால் இது பொதுவாக நினைவாற்றலை வீணடிப்பதாக இருந்தது. ஒரு வரிசை வழக்கமாக இரண்டு அல்லது மூன்று கூறுகளைக் கொண்டிருந்தாலும், அவற்றில் 100 ஐச் சேமிக்க வேண்டிய ஒரு சிறிய வாய்ப்பு கூட இருந்தால், 100 ஐச் சேமிக்கும் திறன் கொண்ட ஒரு வரிசையை உருவாக்க வேண்டியது அவசியம்.

புரோகிராமர்கள் என்ன கொண்டு வந்தார்கள்? அவர்கள் வகுப்பை எழுதினார்கள் ArrayList, இது வகுப்பின் அதே வேலையைச் செய்தது Array, ஆனால் மறுஅளவிடத்தக்கது.

வரிசை பட்டியல் வகுப்பு

வகுப்பின் பெயர் ArrayListஇரண்டு சொற்களிலிருந்து உருவாகிறது: வரிசை + பட்டியல். Arrayஒரு வரிசை மற்றும் Listஒரு பட்டியல்.

ஒவ்வொரு ArrayListபொருளும் ஒரு சாதாரண வரிசை உறுப்புகளைக் கொண்டுள்ளது. ஒரு இலிருந்து கூறுகளை நீங்கள் படிக்கும்போது ArrayList, ​​​​பொருள் அதன் உள் வரிசையில் இருந்து அவற்றை மீட்டெடுக்கிறது. நீங்கள் கூறுகளை எழுதும்போது, ​​​​அது அவற்றை உள் வரிசையில் எழுதுகிறது.

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

• ஒரு குறிப்பிட்ட வகை கூறுகளை சேமிக்கவும்
• பட்டியலின் அளவை மாற்றவும்
• பட்டியலின் முடிவில் கூறுகளைச் சேர்க்கவும்
• பட்டியலின் தொடக்கத்திலோ அல்லது நடுவிலோ உறுப்புகளைச் செருகவும்
• பட்டியலில் எங்கிருந்தும் உறுப்புகளை அகற்றவும்

மேலும் விவரங்களுக்கு, கீழே பார்க்கவும்:

2. ஒரு ArrayListபொருளை உருவாக்குதல்

ஒரு பொருளை உருவாக்க ArrayList, நீங்கள் இது போன்ற குறியீட்டை எழுத வேண்டும்:

ArrayList<TypeParameter> name = new ArrayList<TypeParameter>();

ArrayListசேகரிப்பு வகை/வகுப்பு எங்கே , TypeParameterசேகரிப்பில் சேமிக்கப்பட்ட உறுப்புகளின் வகை ArrayList, மற்றும் nameஇது ஒரு மாறியின் பெயர் ArrayList<TypeParameter>.

மாறி nameஒரு பொதுவான வகையைக் கொண்டுள்ளது. இது இரண்டு வகைகளைக் கொண்டுள்ளது: சேகரிப்பின் வகை முதலில் குறிக்கப்படுகிறது, பின்னர் சேகரிப்பில் சேமிக்கப்பட்ட கூறுகளின் வகையைக் குறிக்க கோண அடைப்புக்குறிகள் பயன்படுத்தப்படுகின்றன.

எடுத்துக்காட்டுகள்:

ArrayList<Integer> list = new ArrayList<Integer>();

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

ArrayList<Double> list = new ArrayList<Double>();

வரிசைகளைப் போலன்றி, சேகரிப்புகள் பழமையான வகைகளை சேமிக்க முடியாது, குறிப்பு வகைகள் மட்டுமே . எனவே உங்களுக்கு கள் தொகுப்பு தேவைப்பட்டால் int, அதற்குப் பதிலாக ரேப்பர் வகுப்பைப் பயன்படுத்தவும் Integer.

3. ஒரு உடன் செயல்பாடுகள்ArrayList

ஆரம்பத்தில், புதிதாக உருவாக்கப்பட்ட பட்டியலின் நீளம் பூஜ்ஜியமாகும், ஏனெனில் அதில் 0 கூறுகள் உள்ளன. பட்டியலில் ஒரு உறுப்பைச் சேர்த்தால், அதன் நீளம் 1 ஆல் அதிகரிக்கிறது. சேர்க்கப்பட்ட உறுப்பை நீக்கினால், நீளம் பூஜ்ஜியமாகக் குறையும்.

பின்வரும் அட்டவணை வகுப்பின் முறைகளைப் பற்றி மேலும் கற்பிக்கலாம் ArrayList:

void add(Type value)

void add(int index, Type value)

Type get(int index)

void set(int index, Type value)

Type remove(int index)

Type remove(Type value)

void clear()

boolean contains(Type value)

boolean isEmpty()

int size()

Type[] toArray(Type[] array)

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

4. ஒப்பீடு ArrayListமற்றும்Array

ArrayListஒப்பிடுவதையும் வரிசையையும் தவிர்க்க முடியாது என்று நினைக்கிறேன் .

வரிசைகள் மூலம் நீங்கள் செய்யக்கூடிய 4 செயல்கள் மட்டுமே உள்ளன:

• ஒரு வரிசையை உருவாக்கவும்
• குறியீட்டின் மூலம் ஒரு உறுப்பைப் பெறுங்கள்
• குறியீட்டின்படி ஒரு உறுப்பை அமைக்கவும்
• வரிசையின் நீளத்தைப் பெறுங்கள்

இந்த செயல்பாடுகள் ஒரு வரிசைக்கு பொருந்தும் மற்றும் ஒரு ArrayList:

String[] array = new String[10];

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

String s = array[0];

String s = list.get(0);

array[0] = "Bye";

list.set(0, "Bye");

int count = array.length;

int count = list.size();

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

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
String[] list = new String[10];

for (int i = 0; i < list.length; i++)
{
    String s = console.nextLine();
    list[i] = s;
}

// Display the contents of the array on the screen
for (int i = 0; i < list.length; i++)
{
    int j = list.length - i - 1;
    System.out.println(list[j]);
}

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < 10; i++)
{
    String s = console.nextLine();
    list.add(s);
}

// Display the contents of the collection on the screen
for (int i = 0; i < list.size(); i++)
{
    int j = list.size() - i - 1;
    System.out.println(list.get(j));
}

ஒப்புமை தெளிவாக உள்ளது. வரிசைகளுக்கு எல்லாம் எப்படியோ குறுகியதாகவும் தெளிவாகவும் இருக்கும். ஆனால் ArrayListகடினமானது அல்ல: ஒரு உறுப்பைப் பெற, நாங்கள் get()முறையைப் பயன்படுத்துகிறோம்; ஒரு உறுப்பை மாற்ற, set()முறை; பட்டியலின் நீளத்தைப் பெற, size()முறை.

புரோகிராமர்கள் வகுப்பை ஏன் பயன்படுத்துகிறார்கள் ArrayList?

முழு புள்ளி, நிச்சயமாக, சாதாரண வரிசைகளில் இல்லாத மற்ற அனைத்து முறைகள்:

• பட்டியலில் ஒரு உறுப்பைச் சேர்க்கவும்
• பட்டியலின் நடுவில் ஒரு உறுப்பைச் சேர்க்கவும்
• பட்டியலில் ஒரு உறுப்பைக் கண்டறியவும்
• பட்டியலிலிருந்து ஒரு உறுப்பை அகற்றுதல்