జావా జాబితా

జావా కలెక్షన్ ఫ్రేమ్‌వర్క్ చాలా ఉపయోగకరమైన ఇంటర్‌ఫేస్‌లను మరియు డేటా స్ట్రక్చర్‌లతో పనిచేయడానికి వాటిని అమలు చేసే తరగతులను కలిగి ఉంది. ఇది చాలా ముఖ్యమైన JDK ఫ్రేమ్‌వర్క్‌లలో ఒకటి అని చెప్పవచ్చు. జాబితా ఇంటర్ఫేస్ చాలా ప్రజాదరణ పొందింది. ఎందుకంటే ప్రోగ్రామింగ్‌లో అన్ని రకాల జాబితాలు లేకుండా ఇది చాలా అవసరం. ఈ వ్యాసంలో, మేము ఈ ఇంటర్‌ఫేస్, జావా జాబితా పద్ధతులు మరియు అమలులను కవర్ చేస్తాము.

జావా జాబితా ఇంటర్ఫేస్

జాబితా గురించిన అతి ముఖ్యమైన విషయం ఏమిటంటే అది ఆర్డర్ చేసిన సేకరణ. మీరు దానిని క్రమం అని కూడా పిలవవచ్చు. జావాలో, జాబితాలు సజాతీయంగా ఉంటాయి, అంటే, జాబితా యొక్క మూలకాలు ఒకే రకమైన డేటాను కలిగి ఉంటాయి. జావా జాబితా ఇంటర్‌ఫేస్ సేకరణ నుండి వారసత్వంగా పొందుతుంది, ఇది దాని అన్ని కార్యకలాపాలను వారసత్వంగా పొందుతుంది. వాటితో పాటు, జాబితాలో కింది కార్యకలాపాలు కూడా సాధ్యమే:

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

జావా జాబితా పద్ధతులు

పై కార్యకలాపాలు జావా జాబితా ఇంటర్‌ఫేస్ యొక్క పద్ధతులలో బహిర్గతం చేయబడ్డాయి. వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:

జాబితా అమలు

జాబితా ఇంటర్‌ఫేస్ అయినందున, ప్రోగ్రామ్‌లు దాని యొక్క నిర్దిష్ట అమలును సృష్టించాలి. మీరు జావా కలెక్షన్స్ APIలో కింది జాబితా అమలుల మధ్య ఎంచుకోవచ్చు:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• 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');

ఇప్పుడు మా స్టాక్‌కు స్ట్రింగ్‌లు మాత్రమే జోడించబడతాయి, లింక్డ్‌లిస్ట్‌కి పూర్ణాంకాలు, మైవెక్టర్‌కి ఫ్లోట్‌లు , మరియు మైలిస్ట్ అనేది అక్షరాల జాబితా.

అర్రేలిస్ట్ ఎలా పనిచేస్తుంది

మీరు ఇప్పటికే సాధారణ శ్రేణుల గురించి తెలిసి ఉంటే, మీరు అర్రేలిస్ట్‌తో కూడా కొంతవరకు సుపరిచితులు. వాస్తవానికి, అర్రేలిస్ట్ అనేది డైనమిక్ శ్రేణి, మరియు దాని లోపల సాధారణ శ్రేణి ఉంటుంది. ఈ శ్రేణి డేటా స్టోర్‌గా పనిచేస్తుంది. అర్రేలిస్ట్ థర్డ్-పార్టీ క్లాస్‌లు, స్ట్రింగ్‌లు, అవుట్‌పుట్ స్ట్రీమ్‌లు మరియు ఇతర సేకరణలతో సహా రిఫరెన్స్ రకాలను, ఏదైనా వస్తువులను మాత్రమే నిల్వ చేస్తుంది. అర్రేలిస్ట్‌లో ఆదిమ డేటా రకాలను నిల్వ చేయడానికి రేపర్ తరగతులు ఉపయోగించబడతాయి. జాబితాను సృష్టించేటప్పుడు, మేము వెంటనే దాని పరిమాణాన్ని సెట్ చేయవచ్చు, కానీ చాలా సందర్భాలలో మేము చేయము. డిఫాల్ట్‌గా, ArrayList పరిమాణం = 10. ArrayListకి కొత్త మూలకాన్ని జోడించడం ఎలా ఉంటుంది? అన్నింటిలో మొదటిది, అంతర్గత శ్రేణిలో తగినంత స్థలం ఉందో లేదో మరియు మరొక మూలకం సరిపోతుందో లేదో తనిఖీ చేయడం ప్రారంభించబడుతుంది. ఖాళీ ఉంటే, కొత్త మూలకం జాబితా చివరకి, అంటే చివరి మూలకాన్ని అనుసరించే సెల్‌కు జోడించబడుతుంది. దీని సూచిక arraylist.size()గా ఉంటుంది. మనం ఇప్పుడే మా జాబితాను సృష్టించి, అది ఖాళీగా ఉంటే, దీని అర్థం arrayList.size() = 0. దీని ప్రకారం, ఇండెక్స్ 0తో సెల్‌కి కొత్త మూలకం జోడించబడుతుంది. తగినంత స్థలం లేదని తేలితే, కొత్తది శ్రేణి పరిమాణం (OldArray * 1.5 పరిమాణం) + 1తో అర్రేలిస్ట్ లోపల సృష్టించబడుతుంది. అదే సూత్రం ప్రకారం, జాబితా మధ్యలో చొప్పించడం జరుగుతుంది, కానీ అదే సమయంలో, చొప్పించిన మూలకాన్ని అనుసరించే అన్ని అంశాలు కుడివైపుకి మార్చబడింది. కాబట్టి, మనకు శ్రేణిలో 5 మూలకాలు ఉంటే మరియు సెల్ నంబర్ 2 (అంటే మూడవది) లోకి ఒక మూలకాన్ని చొప్పించాల్సిన అవసరం ఉంటే, అప్పుడు 0 మరియు 1 శ్రేణి మూలకాలు స్థానంలో ఉంటాయి, సెల్ 2లో కొత్త మూలకం కనిపిస్తుంది మరియు దాని పూర్వీకుడు మూడవ సెల్ మరియు మొదలైన వాటికి వెళుతుంది. ఇండెక్స్ 0తో సెల్‌కి కొత్త మూలకం జోడించబడుతుంది. తగినంత స్థలం లేదని తేలితే, అర్రేలిస్ట్‌లో పరిమాణం (ఓల్డ్‌అరే పరిమాణం * 1.5) + 1తో కొత్త శ్రేణి సృష్టించబడుతుంది. సూత్రం, జాబితా మధ్యలో చొప్పించడం జరుగుతుంది, కానీ అదే సమయంలో, చొప్పించిన మూలకాన్ని అనుసరించే అన్ని మూలకాలు కుడి వైపుకు మార్చబడతాయి. కాబట్టి, మనకు శ్రేణిలో 5 మూలకాలు ఉంటే మరియు సెల్ నంబర్ 2 (అంటే మూడవది) లోకి ఒక మూలకాన్ని చొప్పించాల్సిన అవసరం ఉంటే, అప్పుడు 0 మరియు 1 శ్రేణి మూలకాలు స్థానంలో ఉంటాయి, సెల్ 2లో కొత్త మూలకం కనిపిస్తుంది మరియు దాని పూర్వీకుడు మూడవ సెల్ మరియు మొదలైన వాటికి వెళుతుంది. ఇండెక్స్ 0తో సెల్‌కి కొత్త మూలకం జోడించబడుతుంది. తగినంత స్థలం లేదని తేలితే, అర్రేలిస్ట్‌లో పరిమాణం (ఓల్డ్‌అరే పరిమాణం * 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);
                }
       }

అవుట్‌పుట్ ఇక్కడ ఉంది:

వెక్టర్ కోడ్ ఉదాహరణ

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

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

స్టాక్ యాడ్() మరియు రిమూవ్() పద్ధతులను మాత్రమే కాకుండా పుష్ మరియు పాప్ కూడా కలిగి ఉంటుంది, అవి అటువంటి డేటా నిర్మాణం కోసం క్లాసికల్‌గా ఉంటాయి. స్టాక్ "ఫస్ట్ ఇన్, లాస్ట్ అవుట్" అనే నియమాన్ని పాటిస్తుంది - ఇది అటువంటి వ్యతిరేక క్యూ. కాబట్టి, పాప్ ఆపరేషన్ చివరిగా స్టాక్‌పై ఉంచిన మూలకాన్ని పాప్ చేస్తుంది. మా ఉదాహరణ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది: