जावा वेक्टर

बहुधा तुम्ही जावामध्ये आधीच अ‍ॅरे पाहिल्या असतील आणि तुम्हाला माहिती आहे की त्यांच्यातील एक मुख्य कमतरता म्हणजे आकार स्थिरता. एकदा तुम्ही ठराविक आकाराचा अॅरे तयार केल्यावर, तुम्ही ते नंतर बदलू शकत नाही. जावा भाषेत अनेक जावा कलेक्शन फ्रेमवर्क वर्ग आहेत जे या समस्येचे निराकरण करतात. त्यापैकी एक जावा वेक्टर क्लास आहे. या लेखात चर्चा केली जाईल.

वेक्टर क्लास म्हणजे काय

आम्ही प्रस्तावनेत लिहिल्याप्रमाणे, Java कलेक्शन फ्रेमवर्कमधील वेक्टर क्लास अॅरेच्या स्थिर आकाराची समस्या दूर करतो. Java Vector हा एक प्रकारचा डायनॅमिक अॅरे आहे आणि आकाराने वाढू शकतो किंवा लहान होऊ शकतो. व्हेक्टर कलेक्शन क्लास वापरून , आपण घटकांचा समूह साध्या वस्तू म्हणून संग्रहित करू शकतो आणि विविध पद्धतींद्वारे हाताळू शकतो. वेक्टर क्लास java.util पॅकेजमधून उपलब्ध आहे. अशा प्रकारे, जर तुम्हाला अॅरेचा आकार आधीच माहित नसेल किंवा तुम्हाला प्रोग्रामच्या आयुष्यभरात परिमाणे बदलू शकणार्‍या "अॅरे" ची आवश्यकता असल्यास Java मधील वेक्टर वापरला जाऊ शकतो. हे लगेच म्हटले पाहिजे की वेक्टरवर्ग आधीच बराच जुना आहे, आणि नंतरचे संग्रह दिसू लागले जे बहुतेक प्रकरणांमध्ये त्यास पुनर्स्थित करू शकतात. जावा वेक्टरचा लोकप्रिय “अ‍ॅनालॉग” हा ArrayList वर्ग आहे. या वर्गांमधील सर्वात महत्त्वाचा फरक म्हणजे वेक्टर सिंक्रोनाइझ केला जातो, तर अॅरेलिस्ट नाही. या दोन वर्गांमधील इतर फरक आणि वेक्टर वर्गाच्या अधिक आधुनिक अॅनालॉग्सबद्दल आम्ही थोड्या वेळाने “वेक्टर वर्गात काय चूक आहे” या विभागात बोलू .

जावा वेक्टर पद्धती

येथे जावा वेक्टर पद्धती आहेत:

• व्हॉइड अॅड (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) वेक्टरच्या निर्दिष्ट स्थानावर निर्दिष्ट घटक समाविष्ट करते.

• बुलियन अॅड(ऑब्जेक्ट ओ) वेक्टरच्या शेवटी निर्दिष्ट घटक जोडते.

• boolean addAll(Clection c) निर्दिष्ट कलेक्शनमधील सर्व घटक वेक्टरच्या शेवटी जोडते, ज्या क्रमाने ते निर्दिष्ट कलेक्शन इटरेटरद्वारे परत केले जातात.

• boolean addAll(int index, Collection c) निर्दिष्ट कलेक्शनमधील सर्व घटक निर्दिष्ट स्थानावर वेक्टरमध्ये समाविष्ट करते.

• void addElement(Object obj) या वेक्टरच्या शेवटी निर्दिष्ट घटक जोडते, त्याचा आकार एकाने वाढवते.

• int क्षमता() या वेक्टरची वर्तमान क्षमता परत करते.

• void clear() या वेक्टरमधून सर्व घटक काढून टाकते.

• ऑब्जेक्ट क्लोन() या वेक्टरचा क्लोन देतो.

• बूलियनमध्ये (ऑब्जेक्ट एलिम) या वेक्टरमध्ये निर्दिष्ट ऑब्जेक्ट एक घटक आहे की नाही याची चाचणी करते.

• जर वेक्टरमध्ये निर्दिष्ट कलेक्शनचे सर्व घटक समाविष्ट असतील तर बुलियन समावेशसर्व(संग्रह c) सत्य मिळवते.

• void copyInto(Object[] anArray) या वेक्टरचे घटक निर्दिष्ट अॅरेमध्ये कॉपी करते.

• ऑब्जेक्ट elementAt(int index) निर्दिष्ट निर्देशांकावर घटक परत करतो.

• गणन घटक() या वेक्टरच्या घटकांची प्रगणना देते.

• void sureCapacity(int minCapacity) या वेक्टरची क्षमता वाढवते, आवश्यक असल्यास, ते किमान क्षमता युक्तिवादाने दिलेल्या घटकांची संख्या धारण करू शकते याची खात्री करण्यासाठी.

• boolean equals(Object o) निर्दिष्ट ऑब्जेक्टची या वेक्टरशी तुलना करते.

• ऑब्जेक्ट firstElement() या वेक्टरचा पहिला घटक (इंडेक्स 0 वरील घटक) परत करतो.

• ऑब्जेक्ट गेट(इंट इंडेक्स) या वेक्टरमध्ये निर्दिष्ट स्थानावर घटक परत करतो.

• int hashCode() या वेक्टरसाठी हॅश कोड मूल्य परत करते.

• int indexOf(Object elem) दिलेल्या युक्तिवादाची पहिली घटना शोधते, equals पद्धत वापरून समानतेची चाचणी घेते.

• int indexOf(Object elem, int index) दिलेल्या युक्तिवादाची पहिली घटना शोधते, अनुक्रमणिका पासून सुरू होते आणि समानतेची चाचणी समान पद्धत वापरून करते.

• void insertElementAt(ऑब्जेक्ट ऑब्जेक्ट, इंट इंडेक्स) निर्दिष्ट केलेल्या निर्देशांकावर या व्हेक्टरमध्ये घटक म्हणून निर्दिष्ट ऑब्जेक्ट समाविष्ट करते.

• बुलियन isEmpty() गहाळ घटकांसाठी या वेक्टरची चाचणी करते.

• ऑब्जेक्ट lastElement() वेक्टरचा शेवटचा घटक परत करतो.

• int lastIndexOf(Object elem) या वेक्टरमध्ये निर्दिष्ट केलेल्या ऑब्जेक्टच्या शेवटच्या घटनेची अनुक्रमणिका परत करते.

• int lastIndexOf(Object elem, int index) निर्दिष्ट केलेल्या निर्देशांकापासून सुरू होऊन, निर्दिष्ट ऑब्जेक्टसाठी मागे शोधते आणि त्यास निर्देशांक परत करते.

• ऑब्जेक्ट रिमूव्ह (इंट इंडेक्स) या वेक्टरमधील निर्दिष्ट स्थानावरील घटक काढून टाकते.

• बुलियन रिमूव्ह (ऑब्जेक्ट ओ) या वेक्टरमधील निर्दिष्ट घटकाची पहिली घटना काढून टाकते. वेक्टरमध्ये घटक नसल्यास, ते बदलत नाही.

• बुलियन रिमूव्हऑल(कलेक्शन c) निर्दिष्ट कलेक्शनमध्ये समाविष्ट असलेल्या वेक्टरमधील सर्व घटक काढून टाकते.

• void removeAllElements() व्हेक्टरमधील सर्व घटक काढून टाकते आणि त्याचा आकार शून्यावर सेट करते.

• बुलियन रिमूव्ह एलिमेंट(ऑब्जेक्ट ऑब्जेक्ट) या व्हेक्टरमधून वितर्काची पहिली (सर्वात कमी निर्देशांक) घटना काढून टाकते.

• void removeElementAt(int index) इंडेक्समधील घटक काढून टाकते.

• संरक्षित व्हॉइड रिमूव्ह रेंज(Index from Index, int toIndex) या सूचीमधून सर्व घटक काढून टाकते ज्यांची अनुक्रमणिका केवळ इंडेक्स, समावेशक आणि इंडेक्समधून आहे.

• boolean retainAll(C Collection c) केवळ वेक्टरमधील घटक राखून ठेवते जे निर्दिष्ट कलेक्शनमध्ये समाविष्ट आहेत.

• ऑब्जेक्ट सेट (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) या वेक्टरमधील निर्दिष्ट स्थानावरील घटक निर्दिष्ट घटकासह बदलतो.

• void setElementAt(ऑब्जेक्ट ऑब्जेक्ट, इंट इंडेक्स) दिलेल्या ऑब्जेक्ट म्हणून या वेक्टरच्या निर्दिष्ट निर्देशांकावर घटक सेट करते.

• void setSize(int newSize) या वेक्टरचा आकार सेट करते.

• int size() या वेक्टरमधील घटकांची संख्या परत करते.

• सूची उपसूची(Index fromIndex, int toIndex) या सूचीच्या भागाचे प्रतिनिधित्व (दृश्य) fromIndex, समावेशक आणि toIndex, केवळ देते.

• ऑब्जेक्ट[] toArray() योग्य क्रमाने या व्हेक्टरचे सर्व घटक असलेली अॅरे मिळवते.

• ऑब्जेक्ट[] toArray(Object[] a) योग्य क्रमाने या व्हेक्टरचे सर्व घटक असलेले अॅरे मिळवते; रिटर्न केलेल्या अॅरेचा एक्झिक्युशन प्रकार निर्दिष्ट अॅरेचा प्रकार आहे.

• स्ट्रिंग 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());

   }
}

या प्रोग्रामचे आउटपुट येथे आहे:

वेक्टर क्लासमध्ये काय चूक आहे?

Java Vector वर्गाच्या दस्तऐवजीकरणानुसार , जर तुम्हाला तुमच्या प्रोग्राममध्ये थ्रेड-सेफ अंमलबजावणीची आवश्यकता नसेल, तर व्हेक्टर (कलेक्शन फ्रेमवर्क अधिक प्रभावी सहभागी) च्या जागी ArrayList वापरण्याची शिफारस केली जाते. Vector ऐवजी 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 वापरतात आणि अनेक कारणांसाठी. विशेषतः, गणनेमध्ये रिमूव्ह() पद्धत परिभाषित केलेली नाही , याचा अर्थ पुनरावृत्ती दरम्यान सूची संरचनात्मकरित्या सुधारली जाऊ शकत नाही. तसेच, ListIterator च्या विपरीत, गणन द्विदिशात्मक प्रवेश प्रदान करत नाही. जसे आपण पाहू शकता, वेक्टरमध्ये काही समस्या आहेत. तुम्हाला अद्याप सूची इंटरफेसच्या थ्रेड-सेफ अंमलबजावणीची आवश्यकता असल्यास काय? या प्रकरणात, ArrayList मदत करणार नाही, परंतु आपण वापरू शकता, उदाहरणार्थ, वेक्टर ऐवजी CopyOnWriteArrayList वर्ग ; हे ArrayList चे थ्रेड-सेफ व्हेरियंट म्हणून स्थित आहे. तुम्ही Collections synchronizedList() पद्धत वापरून ArrayList सिंक्रोनाइझ देखील करू शकता .

वेक्टरला खरोखर काही समस्या आहेत... ते अजूनही Java मध्ये का आहे आणि ते का शिकवले पाहिजे?

प्रश्न उद्भवतो: आपण वेक्टर वर्गाचा अभ्यास का करत आहोत? आणि ते अद्याप Java मधून का काढले नाही? वस्तुस्थिती अशी आहे की जावा मागास अनुकूलतेच्या तत्त्वाचा दावा करतो. याचा अर्थ असा की बर्‍याच वर्षांपूर्वी लिहिलेले सर्व जुने कोड Java च्या आधुनिक आवृत्त्यांद्वारे समजले जातील. याव्यतिरिक्त, जावा वातावरणात काही एंटरप्राइझ-स्तरीय अनुप्रयोग आहेत जे अनेक दशकांपासून समर्थित आहेत. हे शक्य आहे की तुम्हाला तुमच्या कामात अशा "डायनासोर" ला सामोरे जावे लागेल, म्हणून तुम्हाला आश्चर्यांसाठी तयार असणे आवश्यक आहे, जसे की कुचकामी लेगसी वर्गांसह कोड.