ஜாவா வெக்டர்

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

வெக்டார் கிளாஸ் என்றால் என்ன

நாம் முன்னுரையில் எழுதியது போல், ஜாவா சேகரிப்பு கட்டமைப்பிலிருந்து வெக்டர் வகுப்பு அணிவரிசைகளின் நிலையான அளவின் சிக்கலை நீக்குகிறது. ஜாவா வெக்டர் என்பது ஒரு வகையான டைனமிக் வரிசை மற்றும் அளவு வளரலாம் அல்லது சுருங்கலாம். வெக்டர் சேகரிப்பு வகுப்பைப் பயன்படுத்தி , தனிமங்களின் ஒரு குழுவை எளிய பொருள்களாகச் சேமித்து, பல்வேறு முறைகள் மூலம் அவற்றைக் கையாளலாம். வெக்டர் வகுப்பு java.util தொகுப்பிலிருந்து கிடைக்கிறது . எனவே, ஜாவாவில் உள்ள வெக்டரை நீங்கள் முன்னரே வரிசையின் அளவு தெரியாவிட்டால் அல்லது நிரலின் வாழ்நாள் முழுவதும் பரிமாணங்களை மாற்றக்கூடிய "வரிசை" உங்களுக்குத் தேவைப்பட்டால் பயன்படுத்தப்படலாம். வெக்டர் என்று உடனே சொல்ல வேண்டும்வகுப்பு ஏற்கனவே மிகவும் பழமையானது, பின்னர் பெரும்பாலான சந்தர்ப்பங்களில் அதை மாற்றக்கூடிய தொகுப்புகள் தோன்றின. ஜாவா வெக்டரின் பிரபலமான "அனலாக்" என்பது வரிசைப்பட்டியல் வகுப்பு. இந்த வகுப்புகளுக்கு இடையே உள்ள மிக முக்கியமான வேறுபாடு என்னவென்றால், வெக்டார் ஒத்திசைக்கப்பட்டுள்ளது, அதே சமயம் வரிசைப்பட்டியல் இல்லை. இந்த இரண்டு வகுப்புகளுக்கும் இடையிலான பிற வேறுபாடுகள் மற்றும் வெக்டர் வகுப்பின் நவீன ஒப்புமைகளைப் பற்றி சிறிது நேரம் கழித்து “வெக்டர் வகுப்பில் என்ன தவறு” என்ற பிரிவில் பேசுவோம் .

ஜாவா திசையன் முறைகள்

ஜாவா திசையன் முறைகள் இங்கே :

• void add(int index, Object element) குறிப்பிட்ட உறுப்பை வெக்டரின் குறிப்பிட்ட நிலையில் செருகுகிறது.

• boolean add(Object o) குறிப்பிட்ட உறுப்பை வெக்டரின் முடிவில் சேர்க்கிறது.

• boolean addAll(சேகரிப்பு c) ஆனது குறிப்பிட்ட சேகரிப்பில் உள்ள அனைத்து கூறுகளையும் திசையன் முடிவில் சேர்க்கிறது, அவை குறிப்பிட்ட சேகரிப்பு இயக்கி மூலம் திருப்பி அனுப்பப்படும்.

• boolean addAll(int index, Collection c) குறிப்பிடப்பட்ட சேகரிப்பில் உள்ள அனைத்து உறுப்புகளையும் குறிப்பிட்ட நிலையில் உள்ள திசையனுக்குள் நுழைக்கிறது.

• void addElement(Object obj) இந்த வெக்டரின் முடிவில் குறிப்பிட்ட கூறுகளைச் சேர்த்து, அதன் அளவை ஒன்று அதிகரிக்கிறது.

• int capacity() இந்த வெக்டரின் தற்போதைய திறனை வழங்குகிறது.

• void clear() இந்த வெக்டரில் இருந்து அனைத்து உறுப்புகளையும் நீக்குகிறது.

• ஆப்ஜெக்ட் குளோன்() இந்த வெக்டரின் குளோனை வழங்குகிறது.

• குறிப்பிட்ட பொருள் இந்த வெக்டரில் உள்ள ஒரு கூறுதானா என்பதை boolean கொண்டுள்ளது(Object elem) சோதனைகள்.

• boolean containsAll(Collection c) ஆனது வெக்டரில் குறிப்பிடப்பட்ட சேகரிப்பின் அனைத்து கூறுகளையும் கொண்டிருந்தால் அது உண்மையாக இருக்கும்.

• void copyInto(Object[] anArray) இந்த வெக்டரின் கூறுகளை குறிப்பிட்ட வரிசைக்கு நகலெடுக்கிறது.

• Object elementAt(int index) குறிப்பிட்ட குறியீட்டில் உள்ள கூறுகளை வழங்குகிறது.

• கணக்கீட்டு உறுப்புகள்() இந்த திசையன் கூறுகளின் கணக்கீட்டை வழங்குகிறது.

• void sureCapacity (int minCapacity) இந்த வெக்டரின் திறனை அதிகரிக்கிறது, தேவைப்பட்டால், குறைந்தபட்ச திறன் வாதத்தால் கொடுக்கப்பட்ட கூறுகளின் எண்ணிக்கையையாவது வைத்திருக்க முடியும் என்பதை உறுதிப்படுத்துகிறது.

• boolean equals(Object o) குறிப்பிட்ட பொருளை இந்த வெக்டருடன் ஒப்பிடுகிறது.

• Object firstElement() இந்த வெக்டரின் முதல் கூறுகளை (குறியீட்டு 0 இல் உள்ள உறுப்பு) வழங்குகிறது.

• ஆப்ஜெக்ட் கெட்(இன்ட் இன்டெக்ஸ்) இந்த வெக்டரில் குறிப்பிட்ட நிலையில் உள்ள உறுப்பை வழங்குகிறது.

• int hashCode() இந்த வெக்டருக்கான ஹாஷ் குறியீடு மதிப்பை வழங்குகிறது.

• int indexOf(Object elem) கொடுக்கப்பட்ட வாதத்தின் முதல் நிகழ்வைத் தேடுகிறது, சமமான முறையைப் பயன்படுத்தி சமத்துவத்தை சோதிக்கிறது.

• int indexOf(Object elem, int index) கொடுக்கப்பட்ட வாதத்தின் முதல் நிகழ்வைத் தேடுகிறது, குறியீட்டில் தொடங்கி, சமமான முறையைப் பயன்படுத்தி சமத்துவத்தை சோதிக்கிறது.

• void insertElementAt(Object obj, int index) குறிப்பிட்ட குறியீட்டில் இந்த வெக்டரில் குறிப்பிடப்பட்ட பொருளை ஒரு அங்கமாகச் செருகுகிறது.

• பூலியன் isEmpty() இந்த வெக்டரை விடுபட்ட கூறுகளை சோதிக்கிறது.

• பொருள் lastElement() திசையனின் கடைசி கூறுகளை வழங்குகிறது.

• int lastIndexOf(Object elem) இந்த வெக்டரில் குறிப்பிடப்பட்ட பொருளின் கடைசி நிகழ்வின் குறியீட்டை வழங்குகிறது.

• int lastIndexOf(Object elem, int index) குறிப்பிட்ட பொருளுக்கு பின்னோக்கி தேடி, குறிப்பிட்ட குறியீட்டில் தொடங்கி, குறியீட்டை அதற்குத் திருப்பித் தருகிறது.

• ஆப்ஜெக்ட் ரிமூவ்(int index) இந்த வெக்டரில் குறிப்பிட்ட நிலையில் உள்ள உறுப்பை நீக்குகிறது.

• boolean remove(Object o) இந்த வெக்டரில் குறிப்பிடப்பட்ட தனிமத்தின் முதல் நிகழ்வை நீக்குகிறது. திசையன் ஒரு உறுப்பு இல்லை என்றால், அது மாறாது.

• boolean removeAll(சேகரிப்பு c) குறிப்பிடப்பட்ட சேகரிப்பில் உள்ள திசையன்களிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது.

• void removeAllElements() வெக்டரில் இருந்து அனைத்து கூறுகளையும் நீக்கி அதன் அளவை பூஜ்ஜியமாக அமைக்கிறது.

• boolean removeElement(Object obj) இந்த வெக்டரில் இருந்து வாதத்தின் முதல் (குறைந்த குறியீட்டு) நிகழ்வை நீக்குகிறது.

• void removeElementAt(int index) குறியீட்டில் உள்ள ஒரு உறுப்பை நீக்குகிறது.

• பாதுகாக்கப்பட்ட void removeRange(int from Index, int toIndex) இந்த பட்டியலிலிருந்து Index, inclusive, toIndex ஆகியவற்றுக்கு இடையே உள்ள அனைத்து கூறுகளையும் பிரத்தியேகமாக நீக்குகிறது.

• boolean retainAll(சேகரிப்பு c) குறிப்பிட்ட சேகரிப்பில் உள்ள வெக்டரில் உள்ள தனிமங்களை மட்டுமே தக்கவைக்கிறது.

• ஆப்ஜெக்ட் செட்(int index, Object உறுப்பு) இந்த வெக்டரில் குறிப்பிட்ட நிலையில் உள்ள உறுப்பை குறிப்பிட்ட உறுப்புடன் மாற்றுகிறது.

• void setElementAt(Object obj, int index) இந்த வெக்டரின் குறிப்பிடப்பட்ட குறியீட்டில் உள்ள கூறுகளை கொடுக்கப்பட்ட பொருளாக அமைக்கிறது.

• void setSize(int newSize) இந்த வெக்டரின் அளவை அமைக்கிறது.

• int size() இந்த வெக்டரில் உள்ள கூறுகளின் எண்ணிக்கையை வழங்குகிறது.

• பட்டியல் சப்லிஸ்ட்(int from Index, int toIndex) இந்த பட்டியலின் பகுதியின் ஒரு பிரதிநிதித்துவத்தை (பார்வை) fromIndex, inclusive, toIndex ஆகியவற்றிற்கு இடையே பிரத்தியேகமாக வழங்குகிறது.

• Object[] toArray() ஆனது இந்த வெக்டரின் அனைத்து கூறுகளையும் சரியான வரிசையில் உள்ள வரிசையை வழங்குகிறது.

• Object[] toArray(Object[] a) இந்த வெக்டரின் அனைத்து கூறுகளையும் சரியான வரிசையில் உள்ள வரிசையை வழங்குகிறது; திரும்பிய வரிசையின் செயல்படுத்தல் வகை குறிப்பிடப்பட்ட வரிசையின் வகையாகும்.

• String toString() ஆனது இந்த வெக்டரின் சரம் பிரதிநிதித்துவத்தை வழங்குகிறது, இதில் ஒவ்வொரு தனிமத்தின் சரம் பிரதிநிதித்துவம் உள்ளது.

• void trimToSize() இந்த வெக்டரின் திறனை வெக்டரின் தற்போதைய அளவிற்கு குறைக்கிறது.

ஜாவா வெக்டார் உதாரணம்

import java.util.Vector;

public class VectorExample {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       //adding some vector elements
       vector.add("Johnny");
       vector.add("Ivy");
       vector.add("Ricky");
       System.out.println(vector); 
       
       //adding more vector elements       
       vector.add("Johnny");
       vector.add("Paul");
       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("Johnny"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Johnny", 1));
       vector.clear(); //deleting all vector elements
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

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

திசையன் வகுப்பில் என்ன தவறு?

ஜாவா வெக்டர் வகுப்பின் ஆவணங்களின்படி , உங்கள் திட்டத்தில் நூல்-பாதுகாப்பான செயலாக்கம் தேவையில்லை என்றால், வெக்டருக்குப் பதிலாக ArrayList ஐப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது (சேகரிப்பு கட்டமைப்பு மிகவும் பயனுள்ள பங்கேற்பாளர்). வெக்டருக்குப் பதிலாக ArrayList வகுப்பைப் பயன்படுத்தி மேலே உள்ள உதாரணத்தை சிறிது மாற்றுவோம் .

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {

       public static void main(String[] args) {
           List vector = new ArrayList();
           //Vector vector = new Vector();
           System.out.println("the size of the empty vector = " +  vector.size());
           vector.add("Johnny");
           vector.add("Ivy");
           vector.add("Ricky");
           System.out.println(vector);
           vector.add("Johnny");
           vector.add("Paul");
           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("Johnny"));
           //program will print out the first appearance of "Johnny" element starting from the element 1
           //System.out.println(vector.indexOf("Johnny", 1));
           vector.clear();
           System.out.println("the size of the vector after clear method = " +  vector.size());

       }
   }

vector.indexOf("ஜானி", 1) உடன் வரியை நாங்கள் கருத்து தெரிவித்தோம் , ஏனெனில் இந்த மாறுபாட்டில் ArrayList வகுப்பில் அத்தகைய முறை இல்லை . அதே காரணத்திற்காக, vector.firstElement() வரி கருத்து தெரிவிக்கப்பட்டது. மற்ற எல்லா விஷயங்களிலும், நிரல் முதல் முடிவைப் போன்ற அதே முடிவைத் தருகிறது. நிச்சயமாக, அத்தகைய எடுத்துக்காட்டில், வெக்டரை விட ArrayList ஏன் சிறந்தது என்பது தெளிவாகத் தெரியவில்லை . இதற்கு இழைகளைப் பற்றிய கூடுதல் அறிவு தேவை. காரணங்களை இங்கே பட்டியலிடுகிறோம். முதலாவதாக, வெக்டார் கிளாஸ் ஒத்திசைக்கப்பட்டிருந்தாலும், அதை முற்றிலும் நூல்-பாதுகாப்பானது என்று அழைக்க முடியாது, இருப்பினும் இது விசித்திரமாகத் தெரிகிறது. உண்மை என்னவென்றால், திசையன் ஒவ்வொரு செயல்பாட்டையும் ஒத்திசைக்கிறது, முழு திசையன் அல்லஉதாரணம் தன்னை. தனிப்பட்ட செயல்பாடுகளை விட முழு செயல்பாடுகளையும் ஒத்திசைக்க வேண்டிய நிரல்களில் இது ஒரு சிக்கலாக இருக்கலாம். சொல்லுங்கள், ஒரு திசையன் மீது ஒரு த்ரெட் திரும்பும் மற்றும் மற்றொரு நூல் திசையன் ஒரு நிகழ்வை கட்டமைப்பு ரீதியாக மாற்றியமைத்தால், மறு செய்கை ஒரு ConcurrentModificationException ஐ வீசும் . இரண்டு இழைகள் வெவ்வேறு செயல்பாடுகளைச் செய்தால் ஒரே நேரத்தில் வெக்டார் நிகழ்வில் வேலை செய்ய முடியும் என்று மாறிவிடும் . இரண்டாவதாக, திசையன்வர்க்கமானது சிறந்த செயல்திறனைக் கொண்டிருக்கவில்லை, ஏனெனில் அதன் பொருள்கள் மறுஅளவிடக்கூடிய வரிசை மற்றும் ஒத்திசைவைக் கொண்டுள்ளன. இந்த கலவையானது ஒத்திசைவு தேவைப்பட்டாலும் இல்லாவிட்டாலும், செயல்பாடுகளைத் தடுப்பதற்கான கூடுதல் மேல்நிலையைக் குறிக்கிறது. நிச்சயமாக, இது செயல்திறனை பாதிக்கிறது. கூடுதலாக, ஒவ்வொரு செயல்பாட்டிலும் வெக்டரை ஒத்திசைப்பது செயல்திறனில் எதிர்மறையான விளைவை ஏற்படுத்துகிறது, ஏனெனில் ஒவ்வொரு செயல்பாட்டிற்கும் மீண்டும் மீண்டும் ஒரு பூட்டைப் பெறுவோம். வகுப்பின் முழு நிகழ்வும் ஒத்திசைக்கப்பட்டிருந்தால், பூட்டு ஒரு முறை பெறப்படும், இது மிகவும் திறமையானது. மூன்றாவதாக, வெக்டர் சில மரபு முறைகளை ஆதரிக்கிறது. எடுத்துக்காட்டாக உறுப்புகள்(). இந்த முறை திசையன் கூறுகளின் எண்ணிக்கையை வழங்குகிறது. ப்ரோகிராமர்கள் பெரும்பாலும் இட்டரேட்டர் அல்லது லிஸ்ட்இட்டரேட்டரை எண்ணிக்கு பயன்படுத்துகின்றனர், மேலும் பல காரணங்களுக்காக. குறிப்பாக, கணக்கீட்டில் நீக்கம்() முறை வரையறுக்கப்படவில்லை, அதாவது மறு செய்கையின் போது பட்டியலை கட்டமைப்பு ரீதியாக மாற்ற முடியாது. மேலும், ListIterator போலல்லாமல், கணக்கீடு இருதரப்பு அணுகலை வழங்காது. நீங்கள் பார்க்க முடியும் என, வெக்டருக்கு சில சிக்கல்கள் உள்ளன. பட்டியல் இடைமுகத்தின் நூல்-பாதுகாப்பான செயலாக்கம் உங்களுக்கு இன்னும் தேவைப்பட்டால் என்ன செய்வது? இந்த வழக்கில், ArrayList உதவாது, ஆனால் நீங்கள் Vector க்குப் பதிலாக CopyOnWriteArrayList வகுப்பைப் பயன்படுத்தலாம் ; இது ArrayList இன் நூல்-பாதுகாப்பான மாறுபாடாக நிலைநிறுத்தப்பட்டுள்ளது. நீங்கள் Collections synchronizedList() முறையைப் பயன்படுத்தி ArrayList ஐ ஒத்திசைக்கலாம் .

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

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