जावा सूची

जावा कलेक्शन फ्रेमवर्क में बहुत उपयोगी इंटरफेस और कक्षाएं हैं जो उन्हें डेटा संरचनाओं के साथ काम करने के लिए लागू करती हैं। यह कहा जा सकता है कि यह JDK के सबसे महत्वपूर्ण ढाँचों में से एक है। सूची इंटरफ़ेस बहुत लोकप्रिय है। क्योंकि प्रोग्रामिंग में सभी प्रकार की सूचियों के बिना यह अनिवार्य है। इस लेख में, हम इस इंटरफ़ेस, जावा सूची विधियों और कार्यान्वयन को कवर करेंगे।

जावा सूची इंटरफ़ेस

सूची के बारे में सबसे महत्वपूर्ण बात यह है कि यह एक क्रमबद्ध संग्रह है। इसे आप क्रम भी कह सकते हैं। जावा में, सूचियाँ सजातीय होती हैं, अर्थात सूची के तत्व समान डेटा प्रकार के होते हैं। जावा सूची इंटरफ़ेस संग्रह से प्राप्त होता है, यह अपने सभी कार्यों को प्राप्त करता है। उनके अलावा, सूची में निम्नलिखित ऑपरेशन भी संभव हैं:

• स्थितीय पहुंच। प्रत्येक तत्व का एक सूचकांक होता है और उनकी स्थिति के आधार पर हेरफेर किया जा सकता है। सूची में। यही है, आप तत्वों को जोड़, बहिष्कृत और संशोधित कर सकते हैं।
• खोजना। आप किसी सूची में किसी तत्व को उसकी सामग्री द्वारा पा सकते हैं और उसकी अनुक्रमणिका वापस कर सकते हैं।
• पुनरावृत्ति। सूची की अनुक्रमिक प्रकृति पुनरावृति विधियों (listIterator) के उपयोग की अनुमति देती है।
• रेंज-व्यू। सबलिस्ट विधि सूची में मनमाने ढंग से श्रेणी संचालन करती है।

जावा सूची के तरीके

उपरोक्त ऑपरेशन जावा सूची इंटरफ़ेस के तरीकों में उजागर किए गए हैं। यहाँ उनमें से कुछ हैं:

सूची कार्यान्वयन

क्योंकि सूची एक इंटरफ़ेस है, कार्यक्रमों को इसका एक ठोस कार्यान्वयन बनाने की आवश्यकता होती है। आप जावा कलेक्शंस एपीआई में निम्नलिखित सूची कार्यान्वयन के बीच चयन कर सकते हैं:

• java.util.ArrayList
• java.util.LinkedList
• java.util.वेक्टर
• java.util.Stack

सूची इंटरफ़ेस का सबसे लोकप्रिय कार्यान्वयन जिसे ArrayList कहा जाता है। बहुत कम बार, लेकिन आप अभी भी वास्तविक कार्यों में लिंक्डलिस्ट का उपयोग देख सकते हैं, लेकिन वेक्टर और स्टैक लंबे समय से नैतिक रूप से अप्रचलित हो गए हैं, इसलिए आप उन्हें केवल प्राचीन विरासत कोड वाली परियोजनाओं में पाएंगे।

सूची इंटरफ़ेस घोषणा

आप निम्न में से किसी एक तरीके से जावा प्रोग्राम में एक सूची घोषित कर सकते हैं:

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 size = 10. ArrayList में एक नया तत्व जोड़ना कैसा दिखता है? सबसे पहले, यह देखने के लिए एक जांच शुरू की जाती है कि आंतरिक सरणी में पर्याप्त जगह है या नहीं और क्या एक और तत्व फिट होगा। यदि स्थान है, तो नया तत्व सूची के अंत में जोड़ा जाता है, अर्थात उस सेल में जो अंतिम तत्व का अनुसरण करता है। इसकी अनुक्रमणिका arraylist.size () होगी। अगर हमने अभी अपनी सूची बनाई है और यह खाली है, तो इसका मतलब है कि arrayList.size() = 0. तदनुसार, एक नया तत्व इंडेक्स 0 के साथ सेल में जोड़ा जाएगा। यदि यह पता चला है कि पर्याप्त जगह नहीं है, तो एक नया सरणी ArrayList के अंदर आकार (OldArray * 1.5 का आकार) + 1 के साथ बनाई गई है। उसी सिद्धांत से, सूची के बीच में एक सम्मिलन होता है, लेकिन साथ ही, सम्मिलित तत्व का पालन करने वाले सभी तत्व होते हैं दाईं ओर स्थानांतरित। इसलिए, यदि हमारे पास सरणी में 5 तत्व हैं, और हमें सेल नंबर 2 (यानी, तीसरा वाला) में एक तत्व डालने की आवश्यकता है, तो 0 और 1 सरणी तत्व जगह में रहते हैं, सेल 2 में एक नया तत्व दिखाई देता है, और इसका पूर्ववर्ती तीसरे सेल में जाता है और इसी तरह। इंडेक्स 0 के साथ सेल में एक नया तत्व जोड़ा जाएगा। यदि यह पता चलता है कि पर्याप्त जगह नहीं है, तो ArrayList के अंदर आकार (OldArray * 1.5 का आकार) + 1 के साथ एक नया एरे बनाया जाता है। उसी के द्वारा सिद्धांत, सूची के बीच में एक सम्मिलन होता है, लेकिन साथ ही, सम्मिलित तत्व का पालन करने वाले सभी तत्वों को दाईं ओर स्थानांतरित कर दिया जाता है। इसलिए, यदि हमारे पास सरणी में 5 तत्व हैं, और हमें सेल नंबर 2 (यानी, तीसरा वाला) में एक तत्व डालने की आवश्यकता है, तो 0 और 1 सरणी तत्व जगह में रहते हैं, सेल 2 में एक नया तत्व दिखाई देता है, और इसका पूर्ववर्ती तीसरे सेल में जाता है और इसी तरह। इंडेक्स 0 के साथ सेल में एक नया तत्व जोड़ा जाएगा। यदि यह पता चलता है कि पर्याप्त जगह नहीं है, तो ArrayList के अंदर आकार (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());

   }
}

यहाँ इस कार्यक्रम का आउटपुट है:

लिंक्डलिस्ट कैसे काम करती है

लिंक्डलिस्ट में, तत्व वास्तव में एक ही श्रृंखला में लिंक होते हैं। प्रत्येक तत्व, इसके द्वारा संग्रहीत डेटा के अतिरिक्त, पिछले और अगले तत्व के लिए एक लिंक है। ये लिंक आपको एक तत्व से दूसरे तत्व में नेविगेट करने की अनुमति देते हैं। इटरेटर दोनों दिशाओं में ट्रैवर्सल का समर्थन करता है। सूची के आरंभ, मध्य और अंत में प्राप्त करने, हटाने और सम्मिलित करने के तरीकों को लागू करता है। आपको अशक्त सहित कोई भी तत्व जोड़ने की अनुमति देता है। लिंक्डलिस्ट दो इंटरफेस को लागू करता है - न केवल सूची, बल्कि डेक भी। यह किसी भी तत्व से एक द्विदिश कतार बनाने की क्षमता प्रदान करता है, यहां तक ​​कि अशक्त भी। लिंक की गई सूची में रखी गई प्रत्येक वस्तु एक नोड (नोड) है। प्रत्येक नोड में एक तत्व होता है, पिछले और अगले नोड के लिए एक लिंक। वास्तव में, लिंक की गई सूची में नोड्स के अनुक्रम होते हैं, जिनमें से प्रत्येक को बनाए जाने पर परिभाषित प्रकार के ऑब्जेक्ट को स्टोर करने के लिए डिज़ाइन किया गया है।

कोड उदाहरण

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);
                }
       }

आउटपुट यहाँ है:

वेक्टर कोड उदाहरण

वेक्टर भी एक गतिशील सरणी प्राप्ति है और यह ArrayList के समान है, लेकिन सिंक्रनाइज़ है और इसमें कुछ विरासत विधियाँ हैं जो संग्रह ढांचे में शामिल नहीं हैं। यहाँ इस वर्ग के उपयोग का एक सरल उदाहरण है।

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());

   }
}

आउटपुट है:

जावा स्टैक क्लास कोड उदाहरण

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);
   }
}

स्टैक में न केवल ऐड () और रिमूव () तरीके हैं, बल्कि पुश और पॉप भी हैं, वे ऐसी डेटा संरचना के लिए शास्त्रीय हैं। स्टैक "फर्स्ट इन, लास्ट आउट" नियम का पालन करता है - यह एक ऐसी विरोधी कतार है। इसलिए, पॉप ऑपरेशन उस तत्व को पॉप करता है जिसे आखिरी बार स्टैक पर रखा गया था। यहाँ हमारे उदाहरण का आउटपुट है: