जावा वेक्टर

संभवतः आप पहले ही जावा में सरणियों के बारे में जान चुके हैं, और आप जानते हैं कि उनकी मुख्य कमियों में से एक आकार स्थिरता है। एक बार जब आप एक निश्चित आकार की एक सरणी बना लेते हैं, तो आप उसे बाद में नहीं बदल सकते। जावा भाषा में कई जावा संग्रह रूपरेखा वर्ग हैं जो इस समस्या को हल करते हैं। उनमें से एक जावा वेक्टर क्लास है। इस लेख में इसकी चर्चा की जाएगी।

वेक्टर क्लास क्या है

जैसा कि हमने प्रस्तावना में लिखा है, जावा कलेक्शन फ्रेमवर्क से वेक्टर वर्ग सरणियों के स्थिर आकार की समस्या को समाप्त करता है। जावा वेक्टर एक प्रकार का गतिशील सरणी है और आकार में बढ़ या घट सकता है। वेक्टर संग्रह वर्ग का उपयोग करके , हम तत्वों के एक समूह को साधारण वस्तुओं के रूप में संग्रहीत कर सकते हैं और विभिन्न तरीकों से उनमें हेरफेर कर सकते हैं। वेक्टर क्लास java.util पैकेज से उपलब्ध है। इस प्रकार, जावा में वेक्टर का उपयोग किया जा सकता है यदि आप पहले से सरणी के आकार को नहीं जानते हैं, या यदि आपको "सरणी" की आवश्यकता है जो कार्यक्रम के जीवनकाल में आयाम बदल सकती है। यह तुरंत कहा जाना चाहिए कि वेक्टरवर्ग पहले से ही काफी पुराना है, और बाद में संग्रह दिखाई दिए जो इसे अधिकांश मामलों में बदल सकते हैं। जावा वेक्टर का लोकप्रिय "एनालॉग" ArrayList वर्ग है। इन वर्गों के बीच एक दूसरे से सबसे महत्वपूर्ण अंतर यह है कि वेक्टर सिंक्रनाइज़ है, जबकि ऐरेलिस्ट नहीं है। हम इन दो वर्गों और वेक्टर वर्ग के अधिक आधुनिक समकक्षों के बीच अन्य अंतरों के बारे में थोड़ी देर बाद "वेक्टर वर्ग के साथ क्या गलत है" अनुभाग में बात करेंगे।

जावा वेक्टर तरीके

यहाँ जावा वेक्टर तरीके हैं:

• शून्य ऐड (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) वेक्टर के निर्दिष्ट स्थान पर निर्दिष्ट तत्व सम्मिलित करता है।

• बूलियन ऐड (ऑब्जेक्ट ओ) वेक्टर के अंत में निर्दिष्ट तत्व जोड़ता है।

• बूलियन एडएल (संग्रह सी) निर्दिष्ट संग्रह में सभी तत्वों को वेक्टर के अंत में जोड़ता है, ताकि वे निर्दिष्ट संग्रह पुनरावर्तक द्वारा लौटाए जा सकें।

• बूलियन एडऑल (इंट इंडेक्स, कलेक्शन सी) निर्दिष्ट संग्रह के भीतर सभी तत्वों को निर्दिष्ट स्थान पर वेक्टर में सम्मिलित करता है।

• शून्य ऐडलेमेंट (ऑब्जेक्ट ओबीजे) इस वेक्टर के अंत में निर्दिष्ट घटक जोड़ता है, इसका आकार एक से बढ़ाता है।

• int क्षमता() इस वेक्टर की वर्तमान क्षमता लौटाती है।

• शून्य स्पष्ट () इस वेक्टर से सभी तत्वों को हटा देता है।

• ऑब्जेक्ट क्लोन () इस वेक्टर का क्लोन लौटाता है।

• बूलियन में (ऑब्जेक्ट एलीम) परीक्षण होता है कि निर्दिष्ट ऑब्जेक्ट इस वेक्टर में एक घटक है या नहीं।

• यदि वेक्टर में निर्दिष्ट संग्रह के सभी तत्व शामिल हैं, तो बूलियन सम्‍मिलित है (संग्रह c) सही है।

• शून्य प्रतिलिपि (ऑब्जेक्ट [] anArray) इस वेक्टर के घटकों को निर्दिष्ट सरणी में कॉपी करता है।

• ऑब्जेक्ट एलिमेंटएट (इंट इंडेक्स) निर्दिष्ट इंडेक्स पर घटक लौटाता है।

• गणना तत्व () इस वेक्टर के घटकों की गणना देता है।

• शून्य सुनिश्चितता (int minCapacity) इस वेक्टर की क्षमता को बढ़ाता है, यदि आवश्यक हो, तो यह सुनिश्चित करने के लिए कि यह न्यूनतम क्षमता तर्क द्वारा दिए गए घटकों की संख्या को कम से कम रख सकता है।

• बूलियन बराबर (ऑब्जेक्ट ओ) निर्दिष्ट ऑब्जेक्ट की इस वेक्टर से तुलना करता है।

• ऑब्जेक्ट फर्स्ट एलिमेंट () इस वेक्टर का पहला घटक (इंडेक्स 0 पर तत्व) लौटाता है।

• ऑब्जेक्ट प्राप्त करें (इंट इंडेक्स) इस वेक्टर में निर्दिष्ट स्थान पर तत्व लौटाता है।

• int हैशकोड () इस वेक्टर के लिए हैश कोड मान लौटाता है।

• int indexOf (ऑब्जेक्ट एलएम) दिए गए तर्क की पहली घटना की खोज करता है, बराबर विधि का उपयोग करके समानता के लिए परीक्षण करता है।

• int indexOf(ऑब्जेक्ट एलीम, इंट इंडेक्स) दिए गए तर्क की पहली घटना को खोजता है, इंडेक्स से शुरू होता है, और बराबर विधि का उपयोग करके समानता के लिए परीक्षण करता है।

• void insertElementAt(Object obj, int index) निर्दिष्ट ऑब्जेक्ट को निर्दिष्ट इंडेक्स पर इस वेक्टर में एक घटक के रूप में सम्मिलित करता है।

• बूलियन isEmpty() लापता घटकों के लिए इस वेक्टर का परीक्षण करता है।

• ऑब्जेक्ट लास्ट एलिमेंट () वेक्टर का अंतिम घटक लौटाता है।

• int lastIndexOf(ऑब्जेक्ट एलएम) इस वेक्टर में निर्दिष्ट ऑब्जेक्ट की अंतिम घटना का इंडेक्स लौटाता है।

• int lastIndexOf(ऑब्जेक्ट एलीम, इंट इंडेक्स) निर्दिष्ट ऑब्जेक्ट के लिए पीछे की ओर खोज करता है, निर्दिष्ट इंडेक्स से शुरू होता है, और इसे इंडेक्स लौटाता है।

• ऑब्जेक्ट रिमूव (इंट इंडेक्स) इस वेक्टर में निर्दिष्ट स्थान पर तत्व को हटा देता है।

• बूलियन रिमूव (ऑब्जेक्ट ओ) इस वेक्टर में निर्दिष्ट तत्व की पहली घटना को हटा देता है। यदि वेक्टर में कोई तत्व नहीं है, तो यह नहीं बदलता है।

• बूलियन रिमूवल (संग्रह c) निर्दिष्ट संग्रह में निहित वेक्टर से सभी तत्वों को हटा देता है।

• शून्य निकालें AllElements() वेक्टर से सभी घटकों को हटा देता है और इसका आकार शून्य पर सेट करता है।

• बूलियन रिमूवल एलिमेंट (ऑब्जेक्ट ओबीजे) इस वेक्टर से तर्क की पहली (सबसे कम अनुक्रमणिका) घटना को हटा देता है।

• शून्य निकालें एलीमेंटएट (इंट इंडेक्स) इंडेक्स पर एक तत्व को हटा देता है।

• संरक्षित शून्य निकालें रेंज (इंडेक्स से int, int toIndex) इस सूची से उन सभी तत्वों को हटा देता है जिनकी अनुक्रमणिका विशेष रूप से इंडेक्स, समावेशी और टूइंडेक्स के बीच है।

• बूलियन रिटेनएल (कलेक्शन सी) वेक्टर में केवल उन तत्वों को बनाए रखता है जो निर्दिष्ट संग्रह में निहित हैं।

• ऑब्जेक्ट सेट (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) निर्दिष्ट तत्व के साथ इस वेक्टर में निर्दिष्ट स्थान पर तत्व को प्रतिस्थापित करता है।

• शून्य सेट एलिमेंटएट (ऑब्जेक्ट ओबीजे, इंट इंडेक्स) दिए गए ऑब्जेक्ट के रूप में इस वेक्टर के निर्दिष्ट इंडेक्स पर घटक सेट करता है।

• void setSize(int newSize) इस वेक्टर का आकार सेट करता है।

• int size() इस वेक्टर में घटकों की संख्या लौटाता है।

• लिस्ट सबलिस्ट(int fromIndex, int toIndex) इस लिस्ट के हिस्से का फ्रॉमइंडेक्स, इनक्लूसिव और टूइंडेक्स के बीच एक्सक्लूसिवली रिप्रेजेंटेशन (व्यू) देता है।

• ऑब्जेक्ट [] toArray() इस वेक्टर के सभी तत्वों को सही क्रम में युक्त एक सरणी देता है।

• ऑब्जेक्ट [] toArray (ऑब्जेक्ट [] ए) इस वेक्टर के सभी तत्वों को सही क्रम में युक्त एक सरणी देता है; लौटाए गए सरणी का निष्पादन प्रकार निर्दिष्ट सरणी का प्रकार है।

• स्ट्रिंग टूस्ट्रिंग () इस वेक्टर का एक स्ट्रिंग प्रतिनिधित्व देता है जिसमें प्रत्येक तत्व का एक स्ट्रिंग प्रतिनिधित्व होता है।

• शून्य 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 वर्ग का उपयोग करते हुए ।

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("Johnny", 1) के साथ लाइन पर टिप्पणी की , क्योंकि ArrayList वर्ग में इस भिन्नता में ऐसी कोई विधि नहीं है । इसी कारण से, vector.firstElement() लाइन पर टिप्पणी की गई थी। अन्य सभी मामलों में, कार्यक्रम पहले वाले के समान ही परिणाम देता है। बेशक, ऐसे उदाहरण में, यह स्पष्ट नहीं है कि ArrayList वेक्टर से बेहतर क्यों है । इसके लिए थ्रेड्स के बारे में अधिक ज्ञान की आवश्यकता होती है। हम यहां कारणों की सूची देते हैं। सबसे पहले, हालांकि वेक्टर वर्ग सिंक्रनाइज़ है, इसे पूरी तरह से थ्रेड-सुरक्षित नहीं कहा जा सकता है, हालांकि यह अजीब लगता है। तथ्य यह है कि वेक्टर प्रत्येक ऑपरेशन को सिंक्रनाइज़ करता है, पूरे वेक्टर को नहींउदाहरण ही। यह उन प्रोग्रामों में एक समस्या हो सकती है जहाँ आपको अलग-अलग संचालन के बजाय संचालन के पूरे सेट को सिंक्रनाइज़ करने की आवश्यकता होती है। उदाहरण के लिए, यदि एक धागा एक सदिश पर पुनरावृति कर रहा है और दूसरा धागा सदिश के एक उदाहरण को संरचनात्मक रूप से संशोधित कर रहा है, तो पुनरावर्तक एक ConcurrentModificationException को फेंक देगा । यह पता चला है कि दो धागे एक ही समय में एक वेक्टर उदाहरण के साथ काम कर सकते हैं यदि वे अलग-अलग ऑपरेशन करते हैं। दूसरे, वेक्टरवर्ग का सर्वश्रेष्ठ प्रदर्शन नहीं है क्योंकि इसकी वस्तुओं में एक आकार बदलने योग्य सरणी और तुल्यकालन है। इस संयोजन का अर्थ है ब्लॉकिंग ऑपरेशन के लिए अतिरिक्त ओवरहेड, चाहे सिंक्रोनाइज़ेशन की आवश्यकता हो या नहीं। ज़रूर, यह प्रदर्शन को प्रभावित करता है। इसके अलावा, प्रत्येक ऑपरेशन पर वेक्टर को सिंक्रनाइज़ करने से भी प्रदर्शन पर नकारात्मक प्रभाव पड़ता है, क्योंकि हम प्रत्येक ऑपरेशन के लिए बार-बार लॉक प्राप्त करेंगे। यदि कक्षा के पूरे उदाहरण को सिंक्रनाइज़ किया गया है, तो लॉक भी एक बार प्राप्त किया जाएगा, जो बहुत अधिक कुशल है। तीसरा, वेक्टर कुछ पुराने तरीकों का समर्थन करता है। उदाहरण के लिए तत्व (). यह विधि वेक्टर के घटकों की गणना लौटाती है। प्रोग्रामर अक्सर गणना करने के लिए और कई कारणों से इटरेटर या लिस्टइटरेटर का उपयोग करते हैं। विशेष रूप से, गणना में एक रिमूव () विधि परिभाषित नहीं है , जिसका अर्थ है कि सूची को पुनरावृति के दौरान संरचनात्मक रूप से संशोधित नहीं किया जा सकता है। इसके अलावा, ListIterator के विपरीत, गणना द्विदिश पहुँच प्रदान नहीं करती है। जैसा कि आप देख सकते हैं, वेक्टर में काफी कुछ समस्याएं हैं। क्या होगा यदि आपको अभी भी सूची इंटरफ़ेस के थ्रेड-सुरक्षित कार्यान्वयन की आवश्यकता है? इस मामले में, ArrayList मदद नहीं करेगा, लेकिन उदाहरण के लिए, आप वेक्टर के बजाय CopyOnWriteArrayList वर्ग का उपयोग कर सकते हैं ; इसे ArrayList के थ्रेड-सुरक्षित संस्करण के रूप में रखा गया है. आप संग्रह सिंक्रनाइज़लिस्ट () विधि का उपयोग करके ArrayList को सिंक्रनाइज़ भी कर सकते हैं।

वेक्टर में वास्तव में कुछ समस्याएं हैं ... यह अभी भी जावा में क्यों है और इसे क्यों सिखाया जाना चाहिए?

सवाल उठता है: हम वेक्टर वर्ग का अध्ययन क्यों कर रहे हैं? और इसे जावा से अभी तक क्यों नहीं हटाया गया? तथ्य यह है कि जावा पिछड़े संगतता के सिद्धांत को मानता है। इसका मतलब है कि कई साल पहले लिखे गए सभी पुराने कोड जावा के आधुनिक संस्करणों द्वारा समझे जा सकेंगे। इसके अलावा, जावा वातावरण में कुछ उद्यम स्तर के अनुप्रयोग हैं जो दशकों से समर्थित हैं। यह बहुत संभव है कि आपको अपने काम में ऐसे "डायनासोर" से निपटना होगा, इसलिए आपको आश्चर्य के लिए तैयार रहने की जरूरत है, जैसे कि अप्रभावी विरासत कक्षाओं के साथ कोड।