జావా వెక్టర్

బహుశా మీరు ఇప్పటికే జావాలో శ్రేణులను చూశారు మరియు వాటి ప్రధాన లోపాలలో ఒకటి పరిమాణం స్థిరత్వం అని మీకు తెలుసు. మీరు నిర్దిష్ట పరిమాణంలో శ్రేణిని సృష్టించిన తర్వాత, మీరు దానిని తర్వాత మార్చలేరు. ఈ సమస్యను పరిష్కరించే జావా భాషలో అనేక జావా కలెక్షన్ ఫ్రేమ్‌వర్క్ తరగతులు ఉన్నాయి. వాటిలో ఒకటి జావా వెక్టర్ క్లాస్. ఇది ఈ వ్యాసంలో చర్చించబడుతుంది.

వెక్టర్ క్లాస్ అంటే ఏమిటి

మేము ముందుమాటలో వ్రాసినట్లుగా, జావా కలెక్షన్ ఫ్రేమ్‌వర్క్ నుండి వెక్టర్ క్లాస్ శ్రేణుల స్టాటిక్ సైజు సమస్యను తొలగిస్తుంది. జావా వెక్టర్ అనేది ఒక రకమైన డైనమిక్ అర్రే మరియు పరిమాణంలో పెరగవచ్చు లేదా కుదించవచ్చు. వెక్టర్ సేకరణ తరగతిని ఉపయోగించి , మేము మూలకాల సమూహాన్ని సాధారణ వస్తువులుగా నిల్వ చేయవచ్చు మరియు వాటిని వివిధ పద్ధతుల ద్వారా మార్చవచ్చు. వెక్టర్ క్లాస్ java.util ప్యాకేజీ నుండి అందుబాటులో ఉంది. అందువల్ల, మీకు అర్రే పరిమాణం ముందుగా తెలియకపోతే లేదా ప్రోగ్రామ్ యొక్క జీవితకాలంలో కొలతలు మార్చగల "శ్రేణి" మీకు అవసరమైతే జావాలోని వెక్టర్ ఉపయోగించబడుతుంది. వెక్టర్ అని వెంటనే చెప్పాలితరగతి ఇప్పటికే చాలా పాతది, మరియు తరువాత సేకరణలు చాలా సందర్భాలలో దానిని భర్తీ చేయగలవు. జావా వెక్టర్ యొక్క ప్రసిద్ధ "అనలాగ్" అర్రేలిస్ట్ క్లాస్. ఒకదానికొకటి నుండి ఈ తరగతుల మధ్య అత్యంత ముఖ్యమైన వ్యత్యాసం ఏమిటంటే వెక్టర్ సమకాలీకరించబడింది, అయితే అర్రేలిస్ట్ కాదు. మేము ఈ రెండు తరగతుల మధ్య ఇతర వ్యత్యాసాల గురించి మరియు వెక్టర్ క్లాస్ యొక్క మరింత ఆధునిక అనలాగ్‌ల గురించి కొంచెం తరువాత “వెక్టర్ క్లాస్‌లో ఏమి తప్పు” విభాగంలో మాట్లాడుతాము .

జావా వెక్టర్ పద్ధతులు

ఇక్కడ జావా వెక్టర్ పద్ధతులు ఉన్నాయి:

• void add(int ఇండెక్స్, ఆబ్జెక్ట్ ఎలిమెంట్) వెక్టార్ యొక్క పేర్కొన్న స్థానం వద్ద పేర్కొన్న మూలకాన్ని ఇన్సర్ట్ చేస్తుంది.

• boolean add(Object o) వెక్టార్ చివర పేర్కొన్న మూలకాన్ని జోడిస్తుంది.

• boolean addAll(కలెక్షన్ సి) పేర్కొన్న సేకరణలోని అన్ని మూలకాలను వెక్టార్ చివరకి జోడిస్తుంది, అవి పేర్కొన్న సేకరణ ఇటరేటర్ ద్వారా తిరిగి వచ్చే క్రమంలో.

• boolean addAll(int index, Collection c) పేర్కొన్న కలెక్షన్‌లోని అన్ని మూలకాలను పేర్కొన్న స్థానం వద్ద వెక్టర్‌లోకి చొప్పిస్తుంది.

• void addElement(Object obj) పేర్కొన్న కాంపోనెంట్‌ని ఈ వెక్టార్ చివరకి జోడిస్తుంది, దాని పరిమాణాన్ని ఒకటి పెంచుతుంది.

• int కెపాసిటీ() ఈ వెక్టర్ యొక్క ప్రస్తుత సామర్థ్యాన్ని అందిస్తుంది.

• void clear() ఈ వెక్టర్ నుండి అన్ని మూలకాలను తొలగిస్తుంది.

• ఆబ్జెక్ట్ క్లోన్() ఈ వెక్టర్ యొక్క క్లోన్‌ని అందిస్తుంది.

• boolean కలిగి(ఆబ్జెక్ట్ ఎలిమ్) ఈ వెక్టార్‌లో పేర్కొన్న వస్తువు ఒక భాగమా అని పరీక్షిస్తుంది.

• వెక్టార్ పేర్కొన్న కలెక్షన్‌లోని అన్ని ఎలిమెంట్‌లను కలిగి ఉన్నట్లయితే boolean containsAll(Collection c) నిజాన్ని అందిస్తుంది.

• void copyInto(Object[] anArray) ఈ వెక్టర్ యొక్క భాగాలను పేర్కొన్న శ్రేణికి కాపీ చేస్తుంది.

• ఆబ్జెక్ట్ ఎలిమెంట్At(int ఇండెక్స్) పేర్కొన్న ఇండెక్స్‌లో కాంపోనెంట్‌ను అందిస్తుంది.

• ఎన్యుమరేషన్ ఎలిమెంట్స్() ఈ వెక్టర్ యొక్క భాగాల గణనను అందిస్తుంది.

• void sureCapacity(int minCapacity) ఈ వెక్టార్ యొక్క సామర్థ్యాన్ని పెంచుతుంది, అవసరమైతే, ఇది కనీస సామర్థ్య వాదన ద్వారా ఇవ్వబడిన భాగాల సంఖ్యను కనీసం కలిగి ఉండేలా చూసుకోవడానికి.

• boolean equals(Object o) పేర్కొన్న వస్తువును ఈ వెక్టర్‌తో పోలుస్తుంది.

• ఆబ్జెక్ట్ ఫస్ట్ ఎలిమెంట్() ఈ వెక్టర్ యొక్క మొదటి భాగం (ఇండెక్స్ 0 వద్ద మూలకం)ని అందిస్తుంది.

• ఆబ్జెక్ట్ గెట్(ఇంట్ ఇండెక్స్) ఈ వెక్టర్‌లో పేర్కొన్న స్థానం వద్ద మూలకాన్ని అందిస్తుంది.

• int hashCode() ఈ వెక్టర్ కోసం హాష్ కోడ్ విలువను అందిస్తుంది.

• int indexOf(Object elem) ఇచ్చిన ఆర్గ్యుమెంట్ యొక్క మొదటి సంభవం కోసం శోధిస్తుంది, సమాన పద్ధతిని ఉపయోగించి సమానత్వం కోసం పరీక్షిస్తుంది.

• int indexOf(Object elem, int index) ఇవ్వబడిన ఆర్గ్యుమెంట్ యొక్క మొదటి సంభవం కోసం శోధిస్తుంది, ఇండెక్స్ నుండి ప్రారంభమవుతుంది మరియు ఈక్వల్స్ పద్ధతిని ఉపయోగించి సమానత్వం కోసం పరీక్షిస్తుంది.

• void insertElementAt(Object obj, int ఇండెక్స్) పేర్కొన్న ఇండెక్స్ వద్ద ఈ వెక్టర్‌లోకి పేర్కొన్న వస్తువును ఒక భాగం వలె చొప్పిస్తుంది.

• boolean isEmpty() తప్పిపోయిన భాగాల కోసం ఈ వెక్టర్‌ని పరీక్షిస్తుంది.

• ఆబ్జెక్ట్ lastElement() వెక్టర్ యొక్క చివరి భాగాన్ని అందిస్తుంది.

• int lastIndexOf(Object elem) ఈ వెక్టర్‌లో పేర్కొన్న వస్తువు యొక్క చివరి సంఘటన యొక్క సూచికను అందిస్తుంది.

• int lastIndexOf(Object elem, int index) పేర్కొన్న వస్తువు కోసం వెనుకకు శోధిస్తుంది, పేర్కొన్న సూచిక నుండి ప్రారంభించి, దానికి సూచికను తిరిగి అందిస్తుంది.

• ఆబ్జెక్ట్ రిమూవ్(ఇంట్ ఇండెక్స్) ఈ వెక్టర్‌లో పేర్కొన్న స్థానం వద్ద మూలకాన్ని తొలగిస్తుంది.

• boolean remove(Object o) ఈ వెక్టర్‌లో పేర్కొన్న మూలకం యొక్క మొదటి సంఘటనను తొలగిస్తుంది. వెక్టర్ ఒక మూలకాన్ని కలిగి ఉండకపోతే, అది మారదు.

• boolean removeAll(కలెక్షన్ సి) పేర్కొన్న కలెక్షన్‌లో ఉన్న వెక్టర్ నుండి అన్ని మూలకాలను తొలగిస్తుంది.

• void removeAllElements() వెక్టర్ నుండి అన్ని భాగాలను తీసివేస్తుంది మరియు దాని పరిమాణాన్ని సున్నాకి సెట్ చేస్తుంది.

• boolean removeElement(Object obj) ఈ వెక్టర్ నుండి ఆర్గ్యుమెంట్ యొక్క మొదటి (అత్యల్ప సూచిక) సంఘటనను తొలగిస్తుంది.

• void removeElementAt(int ఇండెక్స్) ఇండెక్స్ వద్ద ఒక మూలకాన్ని తొలగిస్తుంది.

• రక్షిత శూన్యమైన removeRange (int fromIndex, int toIndex) ఈ జాబితా నుండి ఇండెక్స్, కలుపుకొని మరియు ఇండెక్స్ మధ్య ఉన్న అన్ని మూలకాలను తొలగిస్తుంది.

• boolean retainAll(కలెక్షన్ సి) పేర్కొన్న సేకరణలో ఉన్న వెక్టర్‌లోని మూలకాలను మాత్రమే కలిగి ఉంటుంది.

• ఆబ్జెక్ట్ సెట్ (పూర్ణాంక సూచిక, ఆబ్జెక్ట్ మూలకం) ఈ వెక్టర్‌లో పేర్కొన్న స్థానం వద్ద ఉన్న మూలకాన్ని పేర్కొన్న మూలకంతో భర్తీ చేస్తుంది.

• void setElementAt(Object obj, int ఇండెక్స్) ఈ వెక్టర్ యొక్క పేర్కొన్న ఇండెక్స్ వద్ద కాంపోనెంట్‌ను ఇచ్చిన వస్తువుగా సెట్ చేస్తుంది.

• void setSize(int newSize) ఈ వెక్టర్ పరిమాణాన్ని సెట్ చేస్తుంది.

• int size() ఈ వెక్టర్‌లోని భాగాల సంఖ్యను అందిస్తుంది.

• జాబితా ఉపజాబితా(int fromIndex, int toIndex) ఈ జాబితా యొక్క భాగం యొక్క ప్రాతినిధ్యాన్ని (వీక్షణ) fromIndex, కలుపుకొని మరియు ఇండెక్స్ మధ్య ప్రత్యేకంగా అందిస్తుంది.

• ఆబ్జెక్ట్[] 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());

   }
}

ఈ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ క్రింద ఉంది:

వెక్టర్ క్లాస్‌లో తప్పు ఏమిటి?

జావా వెక్టర్ క్లాస్ యొక్క డాక్యుమెంటేషన్ ప్రకారం , మీ ప్రోగ్రామ్‌లో మీకు థ్రెడ్-సురక్షిత అమలు అవసరం లేకపోతే, వెక్టర్ (కలెక్షన్ ఫ్రేమ్‌వర్క్ మరింత ప్రభావవంతమైన పార్టిసిపెంట్) స్థానంలో అర్రేలిస్ట్‌ని ఉపయోగించమని సిఫార్సు చేయబడింది . వెక్టర్‌కు బదులుగా అర్రేలిస్ట్ క్లాస్‌ని ఉపయోగించి, పై ఉదాహరణను కొద్దిగా మారుద్దాం .

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) తో లైన్‌ను వ్యాఖ్యానించాము , ఎందుకంటే అర్రేలిస్ట్ క్లాస్‌లో ఈ వైవిధ్యంలో అలాంటి పద్ధతి లేదు . అదే కారణంగా, vector.firstElement() లైన్ వ్యాఖ్యానించబడింది. అన్ని ఇతర అంశాలలో, ప్రోగ్రామ్ మొదటి ఫలితానికి సమానమైన ఫలితాన్ని ఇస్తుంది. వాస్తవానికి, అటువంటి ఉదాహరణలో, వెక్టర్ కంటే అర్రేలిస్ట్ ఎందుకు మెరుగ్గా ఉందో స్పష్టంగా తెలియదు . దీనికి థ్రెడ్‌ల గురించి మరింత జ్ఞానం అవసరం. మేము ఇక్కడ కారణాలను జాబితా చేస్తాము. ముందుగా, వెక్టర్ క్లాస్ సింక్రొనైజ్ చేయబడినప్పటికీ, ఇది పూర్తిగా థ్రెడ్-సేఫ్ అని పిలవబడదు, అయినప్పటికీ ఇది వింతగా అనిపిస్తుంది. వాస్తవం ఏమిటంటే వెక్టర్ ప్రతి ఆపరేషన్‌ను సమకాలీకరిస్తుంది, మొత్తం వెక్టర్ కాదుఉదాహరణ కూడా. మీరు వ్యక్తిగత కార్యకలాపాల కంటే మొత్తం కార్యకలాపాల సెట్‌ను సమకాలీకరించాల్సిన ప్రోగ్రామ్‌లలో ఇది సమస్య కావచ్చు. చెప్పండి, ఒక థ్రెడ్ వెక్టార్‌పై మళ్లిస్తుంటే మరియు మరొక థ్రెడ్ వెక్టర్ యొక్క ఉదాహరణను నిర్మాణాత్మకంగా సవరించినట్లయితే, ఇటరేటర్ కాన్‌కరెంట్‌మోడిఫికేషన్ ఎక్సెప్షన్‌ను విసురుతుంది . రెండు థ్రెడ్‌లు వేర్వేరు కార్యకలాపాలను నిర్వహిస్తే ఒకే సమయంలో వెక్టర్ ఉదాహరణతో పని చేయగలవని తేలింది . రెండవది, వెక్టర్తరగతి ఉత్తమ పనితీరును కలిగి లేదు ఎందుకంటే దాని వస్తువులు పునఃపరిమాణం చేయగల శ్రేణి మరియు సమకాలీకరణను కలిగి ఉంటాయి. ఈ కలయిక అంటే సమకాలీకరణ అవసరం లేదా కాకపోయినా, కార్యకలాపాలను నిరోధించడం కోసం అదనపు ఓవర్‌హెడ్. ఖచ్చితంగా, ఇది పనితీరును ప్రభావితం చేస్తుంది. అదనంగా, ప్రతి ఆపరేషన్‌లో వెక్టర్‌ను సమకాలీకరించడం కూడా పనితీరుపై ప్రతికూల ప్రభావాన్ని చూపుతుంది, ఎందుకంటే మేము ప్రతి ఆపరేషన్ కోసం మళ్లీ మళ్లీ లాక్‌ని పొందుతాము. తరగతి యొక్క మొత్తం ఉదాహరణ సమకాలీకరించబడినట్లయితే, లాక్ కూడా ఒకసారి పొందబడుతుంది, ఇది మరింత ప్రభావవంతంగా ఉంటుంది. మూడవదిగా, వెక్టర్ కొన్ని లెగసీ పద్ధతులకు మద్దతు ఇస్తుంది. ఉదాహరణకు మూలకాలు(). ఈ పద్ధతి వెక్టర్ యొక్క భాగాల గణనను అందిస్తుంది. ప్రోగ్రామర్లు చాలా తరచుగా ఇటరేటర్ లేదా లిస్ట్‌ఇటరేటర్‌ని గణనకు ఉపయోగిస్తారు మరియు అనేక కారణాల వల్ల. ప్రత్యేకించి, ఎన్యుమరేషన్‌లో తొలగించు() పద్ధతి నిర్వచించబడలేదు, అంటే పునరావృతం సమయంలో జాబితా నిర్మాణాత్మకంగా సవరించబడదు. అలాగే, ListIterator వలె కాకుండా, ఎన్యుమరేషన్ ద్వి దిశాత్మక ప్రాప్యతను అందించదు. మీరు చూడగలిగినట్లుగా, వెక్టర్‌కు కొన్ని సమస్యలు ఉన్నాయి. మీకు ఇప్పటికీ జాబితా ఇంటర్‌ఫేస్ యొక్క థ్రెడ్-సురక్షిత అమలు అవసరమైతే ఏమి చేయాలి? ఈ సందర్భంలో, అర్రేలిస్ట్ సహాయం చేయదు, కానీ మీరు ఉదాహరణకు, వెక్టర్‌కు బదులుగా CopyOnWriteArrayList తరగతిని ఉపయోగించవచ్చు ; ఇది అర్రేలిస్ట్ యొక్క థ్రెడ్-సేఫ్ వేరియంట్‌గా ఉంచబడింది. మీరు Collections synchronizedList() పద్ధతిని ఉపయోగించి ArrayListని కూడా సమకాలీకరించవచ్చు .

వెక్టర్‌కి నిజంగా కొన్ని సమస్యలు ఉన్నాయి... అది జావాలో ఎందుకు ఉంది మరియు దానిని ఎందుకు నేర్పించాలి?

ప్రశ్న తలెత్తుతుంది: మనం వెక్టర్ తరగతిని ఎందుకు చదువుతున్నాము? మరి ఇది ఇంకా జావా నుండి ఎందుకు తీసివేయబడలేదు? వాస్తవం ఏమిటంటే జావా వెనుకబడిన అనుకూలత సూత్రాన్ని ప్రకటించింది. అంటే చాలా సంవత్సరాల క్రితం వ్రాసిన పాత కోడ్ అంతా జావా యొక్క ఆధునిక సంస్కరణల ద్వారా అర్థం అవుతుంది. అదనంగా, దశాబ్దాలుగా మద్దతునిచ్చే జావా వాతావరణంలో చాలా కొన్ని ఎంటర్‌ప్రైజ్-స్థాయి అప్లికేషన్‌లు ఉన్నాయి. మీరు మీ పనిలో అలాంటి "డైనోసార్"తో వ్యవహరించడం చాలా సాధ్యమే, కాబట్టి మీరు అసమర్థమైన లెగసీ తరగతులతో కోడ్ వంటి ఆశ్చర్యాలకు సిద్ధంగా ఉండాలి.