जावा यादी

जावा कलेक्शन फ्रेमवर्कमध्ये खूप उपयुक्त इंटरफेस आणि क्लासेस आहेत जे डेटा स्ट्रक्चर्ससह कार्य करण्यासाठी त्यांची अंमलबजावणी करतात. असे म्हटले जाऊ शकते की हे सर्वात महत्वाचे जेडीके फ्रेमवर्क आहे. सूची इंटरफेस खूप लोकप्रिय आहे. कारण प्रोग्रामिंगमध्ये सर्व प्रकारच्या सूचीशिवाय ते अपरिहार्य आहे. या लेखात, आम्ही हा इंटरफेस, Java यादी पद्धती आणि अंमलबजावणी समाविष्ट करू.

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

सूचीबद्दल सर्वात महत्वाची गोष्ट म्हणजे ती ऑर्डर केलेली संग्रह आहे. याला तुम्ही क्रम असेही म्हणू शकता. Java मध्ये, याद्या एकसंध असतात, म्हणजेच सूचीचे घटक समान डेटा प्रकाराचे असतात. जावा लिस्ट इंटरफेस कलेक्शनमधून वारसा घेतो, त्याला त्याच्या सर्व ऑपरेशन्सचा वारसा मिळतो. त्यांच्या व्यतिरिक्त, सूचीमध्ये खालील ऑपरेशन्स देखील शक्य आहेत:

• स्थितीत प्रवेश. प्रत्येक घटकाची एक अनुक्रमणिका असते आणि त्यांच्या स्थानावर आधारित हाताळले जाऊ शकते. यादीत म्हणजेच, आपण घटक जोडू, वगळू आणि सुधारित करू शकता.
• शोधा. तुम्ही सूचीमधील घटक त्याच्या सामग्रीनुसार शोधू शकता आणि त्याची अनुक्रमणिका परत करू शकता.
• पुनरावृत्ती. सूचीचे अनुक्रमिक स्वरूप पुनरावृत्ती पद्धती (लिस्टइटरेटर) वापरण्याची परवानगी देते.
• श्रेणी-दृश्य. सबलिस्ट पद्धत सूचीवर अनियंत्रित श्रेणी ऑपरेशन्स करते.

Java यादी पद्धती

वरील ऑपरेशन्स Java List इंटरफेसच्या पद्धतींमध्ये उघड केल्या आहेत. त्यापैकी काही येथे आहे:

सूची अंमलबजावणी

कारण सूची एक इंटरफेस आहे, प्रोग्राम्सना त्याची ठोस अंमलबजावणी तयार करणे आवश्यक आहे. तुम्ही Java Collection API मध्ये खालील सूची अंमलबजावणींमधून निवडू शकता:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

ArrayList नावाच्या लिस्ट इंटरफेसची सर्वात लोकप्रिय अंमलबजावणी. खूप कमी वेळा, परंतु आपण अद्याप वास्तविक कार्यांमध्ये LinkedList चा वापर पाहू शकता, परंतु वेक्टर आणि स्टॅक बर्याच काळापासून नैतिकदृष्ट्या अप्रचलित झाले आहेत, म्हणून बहुधा आपल्याला ते केवळ प्राचीन वारसा कोड असलेल्या प्रकल्पांमध्ये सापडतील.

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

तुम्ही जावा प्रोग्राममधील यादी खालीलपैकी एका प्रकारे घोषित करू शकता:

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 आकार = 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());

   }
}

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

LinkedList कसे कार्य करते

लिंक्डलिस्टमध्ये, घटक प्रत्यक्षात त्याच साखळीतील दुवे असतात. प्रत्येक घटक, तो संचयित करतो त्या डेटा व्यतिरिक्त, मागील आणि पुढील घटकाचा दुवा असतो. हे दुवे तुम्हाला एका घटकातून दुसऱ्या घटकाकडे नेव्हिगेट करण्याची परवानगी देतात. इटरेटर दोन्ही दिशांना ट्रॅव्हर्सलला सपोर्ट करतो. सूचीच्या सुरुवातीला, मध्यभागी आणि शेवटी मिळवणे, काढणे आणि घालणे यासाठी पद्धती लागू करते. तुम्हाला शून्यासह कोणतेही घटक जोडण्याची अनुमती देते. LinkedList दोन इंटरफेस लागू करते - केवळ यादीच नाही तर Deque देखील. हे कोणत्याही घटकांमधून द्विदिशात्मक रांग तयार करण्याची क्षमता प्रदान करते, अगदी शून्य देखील. लिंक केलेल्या सूचीमध्ये ठेवलेली प्रत्येक ऑब्जेक्ट एक नोड (नोड) आहे. प्रत्येक नोडमध्ये एक घटक असतो, मागील आणि पुढील नोडचा दुवा. खरं तर, लिंक केलेल्या सूचीमध्ये नोड्सचा एक क्रम असतो, ज्यापैकी प्रत्येक वस्तू तयार केल्यावर परिभाषित केलेल्या प्रकाराची वस्तू संग्रहित करण्यासाठी डिझाइन केलेली असते.

कोड उदाहरण

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

स्टॅकमध्ये केवळ add() आणि remove() पद्धती नाहीत तर पुश आणि पॉप देखील आहेत, ते अशा डेटा स्ट्रक्चरसाठी शास्त्रीय आहेत. स्टॅक "फर्स्ट इन, लास्ट आउट" या नियमाचे पालन करतो — ही अशी अँटी-क्यू आहे. त्यामुळे, पॉप ऑपरेशन स्टॅकवर शेवटचे ठेवलेले घटक पॉप करते. आमच्या उदाहरणाचे आउटपुट येथे आहे: