ஜாவா பட்டியல்

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

ஜாவா பட்டியல் இடைமுகம்

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

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

ஜாவா பட்டியல் முறைகள்

மேலே உள்ள செயல்பாடுகள் ஜாவா பட்டியல் இடைமுகத்தின் முறைகளில் வெளிப்படும். அவற்றில் சில இங்கே:

பட்டியல் செயல்படுத்தல்

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

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

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

பட்டியல் இடைமுக அறிவிப்பு

பின்வரும் வழிகளில் ஒன்றில் ஜாவா நிரலில் ஒரு பட்டியலை நீங்கள் அறிவிக்கலாம்:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

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

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

அத்தகைய அறிவிப்புடன், அத்தகைய பட்டியல்களின் உறுப்புகளின் தரவு வகை பட்டியலின் துவக்கத்தின் போது தீர்மானிக்கப்படுகிறது, அதாவது, அங்கு கூறுகள் சேர்க்கப்படும் போது.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

இப்போது சரங்களை மட்டுமே எங்கள் அடுக்கில் சேர்க்க முடியும், லிங்க்ட் லிஸ்டில் முழு எண்கள், myVector க்கு மிதவை , மற்றும் myList என்பது எழுத்துகளின் பட்டியல்.

ArrayList எவ்வாறு செயல்படுகிறது

நீங்கள் ஏற்கனவே வழக்கமான வரிசைகளை நன்கு அறிந்திருந்தால், நீங்கள் ArrayList உடன் ஓரளவு அறிந்திருப்பீர்கள். உண்மையில், ArrayList என்பது ஒரு டைனமிக் வரிசை, அதன் உள்ளே ஒரு சாதாரண வரிசை உள்ளது. இந்த வரிசை தரவு சேமிப்பகமாக செயல்படுகிறது. மூன்றாம் தரப்பு வகுப்புகள், சரங்கள், அவுட்புட் ஸ்ட்ரீம்கள் மற்றும் பிற சேகரிப்புகள் உள்ளிட்ட குறிப்பு வகைகள், எந்தப் பொருட்களையும் மட்டுமே ArrayList சேமிக்கிறது. ArrayList இல் பழமையான தரவு வகைகளைச் சேமிக்க ரேப்பர் வகுப்புகள் பயன்படுத்தப்படுகின்றன. ஒரு பட்டியலை உருவாக்கும் போது, ​​உடனடியாக அதன் அளவை அமைக்கலாம், ஆனால் பெரும்பாலான சந்தர்ப்பங்களில் நாம் செய்யவில்லை. இயல்பாக, ArrayList அளவு = 10. ArrayList இல் புதிய உறுப்பைச் சேர்ப்பது எப்படி இருக்கும்? முதலில், உள் வரிசையில் போதுமான இடம் உள்ளதா மற்றும் இன்னும் ஒரு உறுப்பு பொருந்துமா என்பதைப் பார்க்க ஒரு சோதனை தொடங்கப்பட்டது. இடம் இருந்தால், புதிய உறுப்பு பட்டியலின் முடிவில் சேர்க்கப்படும், அதாவது கடைசி உறுப்பைப் பின்தொடரும் கலத்தில். அதன் குறியீடு arraylist.size() ஆக இருக்கும். எங்கள் பட்டியலை உருவாக்கி அது காலியாக இருந்தால், இதன் பொருள் arrayList.size() = 0. அதன்படி, குறியீட்டு 0 உடன் கலத்தில் ஒரு புதிய உறுப்பு சேர்க்கப்படும். போதுமான இடம் இல்லை என்று தெரிந்தால், புதியது வரிசை வரிசைப்பட்டியலில் அளவு (OldArray * 1.5 அளவு) + 1 உடன் உருவாக்கப்படுகிறது. அதே கொள்கையின்படி, பட்டியலின் நடுவில் ஒரு செருகல் நிகழ்கிறது, ஆனால் அதே நேரத்தில், செருகப்பட்ட உறுப்பைப் பின்பற்றும் அனைத்து கூறுகளும் வலது பக்கம் மாற்றப்பட்டது. எனவே, வரிசையில் 5 கூறுகள் இருந்தால், செல் எண் 2 இல் ஒரு உறுப்பைச் செருக வேண்டும் (அதாவது, மூன்றாவது), பின்னர் 0 மற்றும் 1 வரிசை உறுப்புகள் இடத்தில் இருக்கும், செல் 2 இல் ஒரு புதிய உறுப்பு தோன்றும், மேலும் அதன் முன்னோடி மூன்றாவது செல் மற்றும் பலவற்றிற்கு செல்கிறது. குறியீட்டு 0 உடன் கலத்தில் ஒரு புதிய உறுப்பு சேர்க்கப்படும். போதுமான இடம் இல்லை என்று தெரிந்தால், வரிசைப்பட்டியலில் ஒரு புதிய வரிசை உருவாக்கப்பட்டது (OldArray இன் அளவு * 1.5) + 1. அதே மூலம் கொள்கை, ஒரு செருகல் பட்டியலின் நடுவில் நிகழ்கிறது, ஆனால் அதே நேரத்தில், செருகப்பட்ட உறுப்பைப் பின்தொடரும் அனைத்து கூறுகளும் வலதுபுறமாக மாற்றப்படும். எனவே, வரிசையில் 5 கூறுகள் இருந்தால், செல் எண் 2 இல் ஒரு உறுப்பைச் செருக வேண்டும் (அதாவது, மூன்றாவது), பின்னர் 0 மற்றும் 1 வரிசை உறுப்புகள் இடத்தில் இருக்கும், செல் 2 இல் ஒரு புதிய உறுப்பு தோன்றும், மேலும் அதன் முன்னோடி மூன்றாவது செல் மற்றும் பலவற்றிற்கு செல்கிறது. குறியீட்டு 0 உடன் கலத்தில் ஒரு புதிய உறுப்பு சேர்க்கப்படும். போதுமான இடம் இல்லை என்று தெரிந்தால், வரிசைப்பட்டியலில் ஒரு புதிய வரிசை உருவாக்கப்பட்டது (OldArray இன் அளவு * 1.5) + 1. அதே மூலம் கொள்கை, ஒரு செருகல் பட்டியலின் நடுவில் நிகழ்கிறது, ஆனால் அதே நேரத்தில், செருகப்பட்ட உறுப்பைப் பின்தொடரும் அனைத்து கூறுகளும் வலதுபுறமாக மாற்றப்படும். எனவே, வரிசையில் 5 கூறுகள் இருந்தால், செல் எண் 2 இல் ஒரு உறுப்பைச் செருக வேண்டும் (அதாவது, மூன்றாவது), பின்னர் 0 மற்றும் 1 வரிசை உறுப்புகள் இடத்தில் இருக்கும், செல் 2 இல் ஒரு புதிய உறுப்பு தோன்றும், மேலும் அதன் முன்னோடி மூன்றாவது செல் மற்றும் பலவற்றிற்கு செல்கிறது. பட்டியலின் நடுவில் ஒரு செருகல் நிகழ்கிறது, ஆனால் அதே நேரத்தில், செருகப்பட்ட உறுப்பைப் பின்தொடரும் அனைத்து கூறுகளும் வலதுபுறமாக மாற்றப்படும். எனவே, வரிசையில் 5 கூறுகள் இருந்தால், செல் எண் 2 இல் ஒரு உறுப்பைச் செருக வேண்டும் (அதாவது, மூன்றாவது), பின்னர் 0 மற்றும் 1 வரிசை உறுப்புகள் இடத்தில் இருக்கும், செல் 2 இல் ஒரு புதிய உறுப்பு தோன்றும், மேலும் அதன் முன்னோடி மூன்றாவது செல் மற்றும் பலவற்றிற்கு செல்கிறது. பட்டியலின் நடுவில் ஒரு செருகல் நிகழ்கிறது, ஆனால் அதே நேரத்தில், செருகப்பட்ட உறுப்பைப் பின்தொடரும் அனைத்து கூறுகளும் வலதுபுறமாக மாற்றப்படும். எனவே, வரிசையில் 5 கூறுகள் இருந்தால், செல் எண் 2 இல் ஒரு உறுப்பைச் செருக வேண்டும் (அதாவது, மூன்றாவது), பின்னர் 0 மற்றும் 1 வரிசை உறுப்புகள் இடத்தில் இருக்கும், செல் 2 இல் ஒரு புதிய உறுப்பு தோன்றும், மேலும் அதன் முன்னோடி மூன்றாவது செல் மற்றும் பலவற்றிற்கு செல்கிறது.

ஜாவா பட்டியல் எடுத்துக்காட்டு (வரிசைப்பட்டியல் உணர்தல்)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

இந்த திட்டத்தின் வெளியீடு இங்கே:

LinkedList எவ்வாறு செயல்படுகிறது

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

குறியீடு உதாரணம்

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

வெளியீடு இங்கே:

திசையன் குறியீடு எடுத்துக்காட்டு

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

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

வெளியீடு:

Java Stack class code உதாரணம்

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

ஸ்டாக்கில் சேர்() மற்றும் அகற்று() முறைகள் மட்டுமின்றி புஷ் மற்றும் பாப் முறைகளும் உள்ளன , அவை அத்தகைய தரவு கட்டமைப்பிற்கு கிளாசிக்கல் ஆகும். ஸ்டாக் "முதலில், கடைசியாக வெளியேறும்" விதிக்குக் கீழ்ப்படிகிறது - இது அத்தகைய எதிர்ப்பு வரிசை. எனவே, பாப் ஆபரேஷன் கடைசியாக அடுக்கில் வைக்கப்பட்ட உறுப்பைப் பாப்ஸ் செய்கிறது. எங்கள் உதாரணத்தின் வெளியீடு இங்கே: