జావా క్యూ ఇంటర్‌ఫేస్ మరియు దాని అమలులు

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

క్యూ డేటా నిర్మాణం

క్యూ అనేది ఒక లీనియర్ అబ్‌స్ట్రాక్ట్ డేటా స్ట్రక్చర్‌ను నిర్వర్తించే నిర్దిష్ట క్రమాన్ని కలిగి ఉంటుంది — ఫస్ట్ ఇన్ ఫస్ట్ అవుట్ (FIFO). అంటే మీరు నిర్మాణం చివరిలో మాత్రమే ఒక మూలకాన్ని (లేదా ఎన్‌క్యూ, క్యూలో ఉంచండి) జోడించవచ్చు మరియు దాని ప్రారంభం నుండి మాత్రమే ఒక మూలకాన్ని (క్యూ లేదా క్యూ నుండి తీసివేయండి) తీసుకోవచ్చు. మీరు క్యూ డేటా నిర్మాణాన్ని చాలా సులభంగా ఊహించుకోవచ్చు. ఇది నిజ జీవితంలో క్యూ లేదా కస్టమర్ల వరుసలా కనిపిస్తోంది. ముందుగా వచ్చిన కస్టమర్‌కే ముందుగా సేవలందించబోతున్నారు. మీరు మెక్‌డొనాల్డ్స్‌లో లేదా మరెక్కడైనా లైన్‌లో నలుగురు వ్యక్తులు ఉంటే, ముందుగా లైనప్ చేసే వ్యక్తి స్టోర్‌ను పొందే మొదటి వ్యక్తి అవుతాడు. కొత్త కస్టమర్ వస్తే, అతను/ఆమె హాంబర్గర్‌లను పొందే వరుసలో 5వ వ్యక్తి అవుతారు. కాబట్టి, క్యూతో పని చేస్తున్నప్పుడు, చివరకి కొత్త అంశాలు జోడించబడతాయి మరియు మీరు ఒక మూలకాన్ని పొందాలనుకుంటే, అది ప్రారంభం నుండి తీసుకోబడుతుంది. ఇది క్లాసికల్ క్యూ డేటా స్ట్రక్చర్ పని యొక్క ప్రధాన సూత్రం.

జావాలో క్యూ

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

క్యూ పద్ధతులు జావా

క్యూ అనేక పద్ధతులను ప్రకటించింది. ఇంటర్‌ఫేస్ పద్ధతులుగా అవి క్యూను అమలు చేసే అన్ని తరగతులలో ప్రాతినిధ్యం వహించాలి. అత్యంత ముఖ్యమైన క్యూ పద్ధతులు, జావా:

• బూలియన్ ఆఫర్() - సాధ్యమైతే క్యూలో కొత్త మూలకాన్ని చొప్పిస్తుంది
• బూలియన్ యాడ్(E e) - సాధ్యమైతే క్యూలో కొత్త మూలకాన్ని చొప్పిస్తుంది. విజయవంతమైన సందర్భంలో నిజమని చూపుతుంది మరియు ఖాళీ లేనట్లయితే చట్టవిరుద్ధమైన రాష్ట్ర మినహాయింపును విసిరివేస్తుంది.
• ఆబ్జెక్ట్ పోల్() - యొక్క తల నుండి ఒక మూలకాన్ని తిరిగి పొందుతుంది మరియు తొలగిస్తుంది. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.
• ఆబ్జెక్ట్ రిమూవ్() - క్యూ యొక్క హెడ్ నుండి ఒక మూలకాన్ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది.
• ఆబ్జెక్ట్ పీక్() – తిరిగి పొందుతుంది, కానీ క్యూ యొక్క హెడ్ నుండి ఒక మూలకాన్ని తీసివేయదు. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.
• ఆబ్జెక్ట్ ఎలిమెంట్() – తిరిగి పొందుతుంది, కానీ క్యూ హెడ్ నుండి ఎలిమెంట్‌ను తీసివేయదు.

జావా క్యూ యొక్క ఉప ఇంటర్‌ఫేస్‌లు

క్యూ ఇంటర్‌ఫేస్ 4 ఉప ఇంటర్‌ఫేస్‌ల ద్వారా సంక్రమించబడింది – BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E> . మీరు వాటిని 3 గ్రూపులుగా విభజించవచ్చు: Deques, Blocking Quues and Transfer Quues with BlockingDeque మొదటి రెండింటికి చెందినవి. ఈ సమూహాలపై ఒక సంగ్రహావలోకనం తీసుకుందాం.

డెక్యూస్

Deque అంటే D ouble- E nded Q ueue మరియు డేటా యొక్క టెయిల్ నుండి క్యూ (ఫస్ట్-ఇన్-ఫస్ట్-అవుట్/FIFO) లేదా హెడ్ నుండి మరొక ప్రసిద్ధ డేటా స్ట్రక్చర్‌గా స్టాక్ (లాస్ట్-ఇన్-ఇన్-)కి మద్దతు ఇస్తుంది . మొదటి-అవుట్/LIFO). Deque ఇంటర్‌ఫేస్‌ని అమలు చేసే తరగతులు: ArrayDeque, ConcurrentLinkedDeque, LinkedBlockingDeque, LinkedList.

క్యూలను నిరోధించడం

బ్లాకింగ్ క్యూ అనేది రెండు సందర్భాలలో థ్రెడ్‌ను బ్లాక్ చేసే క్యూ:

• థ్రెడ్ ఖాళీ క్యూ నుండి ఎలిమెంట్‌లను పొందడానికి ప్రయత్నిస్తోంది
• థ్రెడ్ పూర్తి క్యూలో ఎలిమెంట్‌లను ఉంచడానికి ప్రయత్నిస్తోంది

ఒక థ్రెడ్ ఖాళీ క్యూ నుండి ఐటెమ్‌లను పొందడానికి ప్రయత్నించినప్పుడు, ఇతర థ్రెడ్ ఐటెమ్‌లను క్యూలో ఉంచే వరకు అది వేచి ఉంటుంది. అదేవిధంగా, ఒక థ్రెడ్ ఎలిమెంట్‌లను పూర్తి క్యూలో ఉంచడానికి ప్రయత్నించినప్పుడు, ఎలిమెంట్‌లకు ఖాళీ స్థలాన్ని పొందడానికి కొన్ని ఇతర థ్రెడ్ ఎలిమెంట్‌లను క్యూ నుండి బయటకు తీసే వరకు వేచి ఉంటుంది. ఖచ్చితంగా, "పూర్తి క్యూ" అనే భావన క్యూ పరిమిత పరిమాణాన్ని కలిగి ఉందని సూచిస్తుంది, ఇది సాధారణంగా కన్స్ట్రక్టర్‌లో పేర్కొనబడుతుంది. ప్రామాణిక బ్లాకింగ్ క్యూలలో లింక్డ్‌బ్లాకింగ్ క్యూ, సింక్రోనస్ క్యూ మరియు అర్రేబ్లాకింగ్ క్యూ ఉన్నాయి. BlockingQueue ఇంటర్‌ఫేస్ తరగతులను అమలు చేస్తోంది : ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, PriorityBlockingQueue, SynchronousQueue. BlockingDequeBlockingQueue కోసం ఉప ఇంటర్‌ఫేస్. BlockingQueue వంటి BlockingDeque నిరోధించే క్యూ, కానీ ద్వి దిశాత్మకం. కనుక ఇది Deque ఇంటర్ఫేస్ యొక్క లక్షణాలను వారసత్వంగా పొందుతుంది. ఇది బహుళ-థ్రెడ్ అమలుకు ఉద్దేశించబడింది, సున్నా మూలకాలను అనుమతించదు మరియు సామర్థ్యం పరిమితం కావచ్చు. BlockingDeque ఇంటర్‌ఫేస్ యొక్క ఇంప్లిమెంటేషన్‌లు క్యూ ఖాళీగా ఉన్నట్లయితే ఎలిమెంట్‌లను పొందడం మరియు అది నిండినట్లయితే క్యూలో ఒక ఎలిమెంట్‌ని జోడించడం యొక్క ఆపరేషన్‌ను బ్లాక్ చేస్తుంది.

బదిలీ క్యూలు

TransferQueue ఇంటర్‌ఫేస్ BlockingQueue ఇంటర్‌ఫేస్‌ను విస్తరించింది. అయితే BlockingQueue ఇంటర్‌ఫేస్ క్యూల అమలు వలె కాకుండా, క్యూ ఖాళీగా ఉంటే (రీడింగ్) థ్రెడ్‌లను బ్లాక్ చేయవచ్చు లేదా క్యూ నిండినట్లయితే (వ్రాయడం), TransferQueue ఇంటర్‌ఫేస్ క్యూలు మరొక స్ట్రీమ్ మూలకాన్ని తిరిగి పొందే వరకు రైట్ స్ట్రీమ్‌ను బ్లాక్ చేస్తాయి. దీని కోసం బదిలీ పద్ధతిని ఉపయోగించండి. మరో మాటలో చెప్పాలంటే, BlockingQueue అమలు చేయడం వలన నిర్మాత సృష్టించిన మూలకం తప్పనిసరిగా క్యూలో ఉండాలని హామీ ఇస్తుంది, అయితే TransferQueue అమలు చేయడం వలన నిర్మాత మూలకం వినియోగదారు "స్వీకరించబడుతుందని" హామీ ఇస్తుంది. TransferQueue ఇంటర్‌ఫేస్ యొక్క అధికారిక జావా అమలు ఒక్కటే ఉంది — LinkedTransferQueue.

జావా క్యూ అమలులు

క్యూ ఇంటర్‌ఫేస్‌ని అమలు చేసే అనేక తరగతులు ఉన్నాయి:

• క్యూ జావా 8 డాక్స్ ప్రకారం AbstractQueue , ఈ వియుక్త తరగతి కొన్ని క్యూ ఆపరేషన్ల ప్రాథమిక అమలులను అందిస్తుంది. ఇది శూన్య అంశాలను అనుమతించదు. వరుసగా క్యూ క్లాసికల్ ఆఫర్ , పోల్ , మరియు పీక్ ఆధారంగా మరో 3 పద్ధతులు జోడించడం, తీసివేయడం మరియు మూలకం ఉన్నాయి . అయినప్పటికీ వారు తప్పుడు లేదా శూన్య రాబడి ద్వారా వైఫల్యాన్ని సూచించే బదులు మినహాయింపులను విసిరారు.
• ArrayBlockingQueue — శ్రేణి ద్వారా మద్దతునిచ్చే స్థిర పరిమాణం FIFO నిరోధించే క్యూ
• ArrayDeque — Deque ఇంటర్‌ఫేస్ యొక్క పునర్పరిమాణ శ్రేణి అమలు
• ConcurrentLinkedDeque — లింక్డ్ నోడ్‌ల ఆధారంగా అపరిమిత ఏకకాలిక డీక్యూ.
• ConcurrentLinkedQueue — లింక్ చేయబడిన నోడ్‌ల ఆధారంగా అపరిమిత థ్రెడ్-సేఫ్ క్యూ.
• DelayQueue — హీప్‌తో కూడిన సమయ-ఆధారిత షెడ్యూలింగ్ క్యూ
• LinkedBlockingDeque — Deque ఇంటర్‌ఫేస్ యొక్క ఏకకాలిక అమలు.
• LinkedBlockingQueue — ఒక ఐచ్ఛికంగా పరిమితమైన FIFO బ్లాకింగ్ క్యూ లింక్డ్ నోడ్‌లచే మద్దతు ఇవ్వబడుతుంది
• లింక్డ్‌లిస్ట్ — జాబితా మరియు డీక్యూ ఇంటర్‌ఫేస్‌ల యొక్క రెట్టింపు-లింక్డ్ జాబితా అమలు. అన్ని ఐచ్ఛిక జాబితా కార్యకలాపాలను అమలు చేస్తుంది మరియు అన్ని అంశాలను (శూన్యంతో సహా) అనుమతిస్తుంది
• LinkedTransferQueue — లింక్డ్ నోడ్‌ల ఆధారంగా అపరిమిత బదిలీ క్యూ
• PriorityBlockingQueue — కుప్ప మద్దతుతో అపరిమిత నిరోధించే ప్రాధాన్యత క్యూ
• PriorityQueue — హీప్ డేటా స్ట్రక్చర్ ఆధారంగా ఒక ప్రాధాన్యత క్యూ
• SynchronousQueue — ప్రతి ఇన్సర్ట్ ఆపరేషన్ మరొక థ్రెడ్ ద్వారా సంబంధిత తొలగింపు ఆపరేషన్ కోసం వేచి ఉండాల్సిన ఒక బ్లాకింగ్ క్యూ, మరియు దీనికి విరుద్ధంగా.

లింక్డ్‌లిస్ట్, అర్రేబ్లాకింగ్ క్యూ మరియు ప్రయారిటీక్యూ అత్యంత ప్రజాదరణ పొందిన అమలులు. వాటిని చూద్దాం మరియు మంచి అవగాహన కోసం కొన్ని ఉదాహరణలను చేద్దాం.

లింక్డ్లిస్ట్

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

లింక్డ్‌లిస్ట్ కన్‌స్ట్రక్టర్‌లు

పారామితులు లేకుండా LinkedList() ఖాళీ జాబితాను నిర్మించడానికి ఉపయోగించబడుతుంది. లింక్డ్‌లిస్ట్(కలెక్షన్<? పొడిగిస్తుంది E> c) అనేది పేర్కొన్న సేకరణ యొక్క మూలకాలను కలిగి ఉన్న జాబితాను సృష్టించడం కోసం, క్రమంలో, అవి సేకరణ యొక్క పునరావృత్తి ద్వారా అందించబడతాయి.

ప్రధాన లింక్డ్‌లిస్ట్ పద్ధతులు:

• add(E మూలకం) ఈ జాబితా చివర పేర్కొన్న మూలకాన్ని జోడిస్తుంది;
• add(int సూచిక, E మూలకం) పేర్కొన్న స్థాన సూచిక వద్ద మూలకాన్ని చొప్పిస్తుంది;
• get(int ఇండెక్స్) ఈ జాబితాలో పేర్కొన్న స్థానం వద్ద మూలకాన్ని అందిస్తుంది;
• తొలగించు(int సూచిక) స్థానం సూచిక వద్ద ఉన్న మూలకాన్ని తొలగిస్తుంది;
• తొలగించు(Object o) ఈ జాబితా నుండి ?o మూలకం యొక్క మొదటి సంభవనీయతను తొలగిస్తుంది.
• remove() జాబితా యొక్క మొదటి మూలకాన్ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది.
• addFirst(), addLast() ఒక మూలకాన్ని జాబితా ప్రారంభం/ముగింపుకు జోడించండి
• clear() జాబితా నుండి అన్ని అంశాలను తొలగిస్తుంది
• జాబితాలో o మూలకం ఉంటే కలిగి(Object o) నిజాన్ని అందిస్తుంది.
• indexOf(Object o) అనేది o మూలకం యొక్క మొదటి సంభవం యొక్క సూచికను అందిస్తుంది, లేదా అది జాబితాలో లేకుంటే -1.
• సెట్ (int సూచిక, E మూలకం) మూలకంతో ఇండెక్స్ స్థానంలో ఉన్న మూలకాన్ని భర్తీ చేస్తుంది
• size()జాబితాలోని మూలకాల పరిమాణాన్ని అందిస్తుంది.
• toArray() మొదటి నుండి చివరి మూలకం వరకు అన్ని జాబితా మూలకాలను కలిగి ఉన్న శ్రేణిని అందిస్తుంది.
• pop() స్టాక్ నుండి ఒక మూలకాన్ని పాప్ చేస్తుంది (జాబితా ద్వారా సూచించబడుతుంది)
• పుష్(E e) ఒక మూలకాన్ని స్టాక్‌పైకి నెట్టివేస్తుంది (ఈ జాబితా ద్వారా సూచించబడుతుంది)

జావా క్యూ ఉదాహరణ - లింక్డ్‌లిస్ట్ (వివిధ మార్గాల్లో మూలకాలను ఉంచడం మరియు తీసివేయడం)

import java.util.*;
 
public class LinkedListTest {
 
       public static void main(String args[]){
 
           LinkedList<Integer> myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           //put one element into the head, not to the tail:
           myLinkedList.push(5);
           System.out.println("The new element last in will be the first: " + myLinkedList);
           //add new element at the specified position:
           myLinkedList.add(4,3);
           //put one element into the head, not to the tail (same as push):
           myLinkedList.addFirst(6);
           System.out.println(myLinkedList);
           //now remove element no 2 (it is 1):
           myLinkedList.remove(2);
           System.out.println(myLinkedList);
           //now remove the head of the list
           myLinkedList.pop();
           System.out.println(myLinkedList);
           //remove with the other method
           myLinkedList.remove();
           System.out.println(myLinkedList);
           //and with one more
           myLinkedList.poll();
           System.out.println(myLinkedList);
       }
       }

ప్రాధాన్యత క్యూ

PriorityQueue అనేది FIFO సాధారణ అర్థంలో సరిగ్గా క్యూ కాదు. ప్రాధాన్య క్యూలోని మూలకాలు వాటి సహజ క్రమానికి అనుగుణంగా లేదా క్యూ నిర్మాణ సమయంలో అందించబడిన కంపారిటర్ ద్వారా ఏ కన్స్ట్రక్టర్ ఉపయోగించబడుతుందో బట్టి ఆర్డర్ చేయబడతాయి. అయితే ఇది జాబితా (అతిపెద్దది నుండి చిన్నది లేదా వైస్ వెర్సా) వంటి సరళ నిర్మాణంలో ఉండే క్రమం కాదు. ప్రాధాన్య నిమి హీప్ ఆధారంగా ప్రాధాన్య క్యూ. హీప్ అనేది బైనరీ ట్రీ ఆధారంగా డేటా స్ట్రక్చర్. ప్రతి తల్లిదండ్రుల ప్రాధాన్యత తన పిల్లల ప్రాధాన్యతల కంటే ఎక్కువగా ఉంటుంది. ప్రతి పేరెంట్‌కు ఇద్దరు కంటే ఎక్కువ పిల్లలు లేనట్లయితే ఒక చెట్టును పూర్తి బైనరీ అంటారు, మరియు స్థాయిల పూరకం పై నుండి క్రిందికి వెళుతుంది (అదే స్థాయి నుండి - ఎడమ నుండి కుడికి). బైనరీ హీప్ దాని నుండి కొత్త మూలకం జోడించబడిన లేదా తీసివేయబడిన ప్రతిసారీ దానినే పునర్వ్యవస్థీకరించుకుంటుంది. min-heap విషయంలో, అతిచిన్న మూలకం దాని చొప్పించే క్రమంతో సంబంధం లేకుండా మూలానికి వెళుతుంది. ఈ మిని-హీప్ ఆధారంగా ప్రాధాన్యత క్యూ, కాబట్టి మనకు పూర్ణాంకాల ప్రాధాన్యత క్యూ ఉంటే, దాని మొదటి మూలకం ఈ సంఖ్యలలో చిన్నది అవుతుంది. మీరు రూట్‌ను తొలగిస్తే, తదుపరి చిన్నది రూట్ అవుతుంది.

ప్రధాన ప్రాధాన్యత వరుస పద్ధతులు:

• boolean add(object) ప్రాధాన్యత క్యూలో పేర్కొన్న మూలకాన్ని ఇన్సర్ట్ చేస్తుంది. విజయం విషయంలో నిజం తిరిగి వస్తుంది. క్యూ నిండినట్లయితే, పద్ధతి మినహాయింపును అందిస్తుంది.
• boolean offer(object) ఈ ప్రాధాన్యత క్యూలో పేర్కొన్న మూలకాన్ని ఇన్‌సర్ట్ చేస్తుంది. క్యూ నిండినట్లయితే, పద్ధతి తప్పుగా చూపబడుతుంది.
• boolean remove(object) ఈ క్యూ నుండి పేర్కొన్న మూలకం యొక్క ఒక ఉదాహరణను తొలగిస్తుంది, అది ఉన్నట్లయితే.
• ఆబ్జెక్ట్ పోల్() ఈ క్యూ యొక్క హెడ్‌ను తిరిగి పొందుతుంది మరియు తీసివేస్తుంది. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.
• void clear() ప్రాధాన్యత క్యూ నుండి అన్ని మూలకాలను తొలగిస్తుంది.
• ఆబ్జెక్ట్ ఎలిమెంట్() ఈ క్యూ యొక్క హెడ్‌ని తీసివేయకుండానే తిరిగి పొందుతుంది. క్యూ ఖాళీగా ఉంటే NoSuchElementExceptionని విసురుతుంది.
• ఆబ్జెక్ట్ పీక్() క్యూ యొక్క హెడ్‌ని తీసివేయకుండా తిరిగి పొందుతుంది. క్యూ ఖాళీగా ఉంటే శూన్యం చూపుతుంది.
• క్యూలో o మూలకం ఉంటే boolean కలిగి (Object o) నిజాన్ని అందిస్తుంది.
• int size() ఈ క్యూలోని మూలకాల సంఖ్యను అందిస్తుంది.

ప్రాధాన్యత క్యూ యొక్క ఉదాహరణ

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
 
public class PriorityQueueExample {
   public static void main(String[] args) {
 
       Queue<Integer> queueL = new LinkedList<>();
       for (int i = 5; i > 0; i--) {
           queueL.add(i);
       }
       System.out.println("Print our LinkedList Queue (FIFO): " + queueL);
       Queue<Integer> priorityQueue = new PriorityQueue<>();
 
       for (int i = 5; i > 0; i--) {
       priorityQueue.offer(i);
       }
 
       System.out.println("PriorityQueue printing (by iterating, no elements removing): " + priorityQueue);
       System.out.println("Print PriorityQueue using poll() (by retrieval): " );
       while (!priorityQueue.isEmpty()) {
           System.out.println(priorityQueue.poll());
       }
}
}
Print our LinkedList Queue (FIFO): [5, 4, 3, 2, 1]
PriorityQueue printing (by iterating, no elements removing): [1, 2, 4, 5, 3]
Print our  PriorityQueue using poll() (by retrieval): 
1
2
3
4
5

ప్రాధాన్యత క్యూలు బైనరీ హీప్స్‌పై ఆధారపడి ఉన్నాయని అర్థం చేసుకోవడం ముఖ్యం, కాబట్టి అవి ఎలిమెంట్‌లను లీనియర్ క్రమబద్ధీకరించిన క్రమంలో ఉంచవు. మూలం నుండి ఆకు వరకు ప్రతి మార్గం ఆదేశించబడింది, కానీ వేరు నుండి వేర్వేరు మార్గాలు కాదు. అంటే మీరు క్యూ యొక్క కనీస మూలకాన్ని చాలా త్వరగా పొందవచ్చు. మీరు ప్రతిసారీ తలని తొలగిస్తే, మీరు క్రమబద్ధీకరించబడిన నిర్మాణాన్ని ప్రింట్ చేస్తారు.

అర్రేబ్లాకింగ్ క్యూ

ArrayBlockingQueue యొక్క అంతర్గత డేటా నిర్మాణంమూలకాలను నిల్వ చేయడానికి వృత్తాకార శ్రేణిపై ఆధారపడి ఉంటుంది. క్యూ యొక్క తోకలో కొత్త మూలకాలు చొప్పించబడిన సందర్భంలో ఇది ఒక సాధారణ క్యూ (FIFO), మరియు వెలికితీత కార్యకలాపాలు క్యూ యొక్క తల నుండి మూలకాన్ని తిరిగి అందిస్తాయి. ఒకసారి సృష్టించిన క్యూ సామర్థ్యాన్ని మార్చలేరు. పూర్తి క్యూలో మూలకాన్ని చొప్పించడానికి (పుట్) చేసే ప్రయత్నాలు ప్రవాహాన్ని నిరోధించడానికి దారితీస్తాయి; ఖాళీ క్యూ నుండి మూలకాన్ని తీసుకోవడానికి ప్రయత్నించడం కూడా థ్రెడ్‌ను బ్లాక్ చేస్తుంది. మేము ముందే చెప్పినట్లుగా, ఈ శ్రేణి వృత్తాకారంగా ఉంటుంది. అంటే శ్రేణి యొక్క మొదటి మరియు చివరి అంశాలు తార్కికంగా ప్రక్కనే పరిగణించబడతాయి. మీరు ఎలిమెంటోను క్యూలో ఉంచినప్పుడు లేదా క్యూ నుండి తీసివేసిన ప్రతిసారీ క్యూ తల మరియు తోక మూలకాల సూచికలను అభివృద్ధి చేస్తుంది. కొన్ని సూచికలు శ్రేణి యొక్క చివరి మూలకాన్ని ముందుకు తీసుకువెళితే, అది 0 నుండి పునఃప్రారంభించబడుతుంది. అందువల్ల, తల తొలగించే సందర్భంలో (సాధారణ శ్రేణిలో వలె) క్యూ అన్ని మూలకాలను మార్చాల్సిన అవసరం లేదు. అయితే, మధ్య నుండి ఒక మూలకాన్ని తీసివేసిన సందర్భంలో (Iterator.remove ఉపయోగించి), మూలకాలు మార్చబడతాయి. ArrayBlockingQueue నిర్మాతలు (ఎలిమెంట్లను చొప్పించడం) మరియు వినియోగదారుల (ఎలిమెంట్‌లను వెలికితీసే) వేచి ఉండే పనిని ఆర్డర్ చేయడానికి కన్స్ట్రక్టర్‌లో ఫెయిర్ పారామీటర్‌తో అదనపు ఫెయిర్‌నెస్ పాలసీకి మద్దతు ఇస్తుంది . డిఫాల్ట్‌గా, ఆర్డర్ హామీ ఇవ్వబడదు. అయితే "ఫెయిర్ == ట్రూ"తో క్యూ సృష్టించబడితే, అర్రేబ్లాకింగ్ క్యూ క్లాస్ అమలు FIFO క్రమంలో థ్రెడ్ యాక్సెస్‌ను అందిస్తుంది. ఈక్విటీ సాధారణంగా బ్యాండ్‌విడ్త్‌ను తగ్గిస్తుంది, అయితే అస్థిరతను తగ్గిస్తుంది మరియు వనరులు అయిపోకుండా నిరోధిస్తుంది.

అర్రేబ్లాకింగ్ క్యూ క్లాస్ కన్స్ట్రక్టర్లు

• ArrayBlockingQueue (int కెపాసిటీ) స్థిర సామర్థ్యం మరియు డిఫాల్ట్ యాక్సెస్ విధానంతో క్యూను సృష్టిస్తుంది.
• ArrayBlockingQueue (పూర్ణాంక సామర్థ్యం, ​​బూలియన్ ఫెయిర్) స్థిర సామర్థ్యం మరియు నిర్దిష్ట యాక్సెస్ విధానంతో క్యూను సృష్టిస్తుంది.
• ArrayBlockingQueue (int కెపాసిటీ, బూలియన్ ఫెయిర్, కలెక్షన్ <? పొడిగింపు E> c) యాక్సెస్ విధానం ద్వారా నిర్దేశించబడిన స్థిర సామర్థ్యంతో క్యూను సృష్టిస్తుంది మరియు క్యూలో ఎలిమెంట్‌లను కలిగి ఉంటుంది.

ఇక్కడ మేము BlockingQueueExample ఉదాహరణను పొందాము. మేము ఒక మూలకం సామర్థ్యం మరియు సరసమైన ఫ్లాగ్‌తో ArrayBlockingQueue యొక్క క్యూను సృష్టిస్తాము. రెండు థ్రెడ్‌లు ప్రారంభించబడ్డాయి. వాటిలో మొదటిది, ప్రొడ్యూసర్ థ్రెడ్, పుట్ పద్ధతిని ఉపయోగించి సందేశాల శ్రేణి నుండి సందేశాలను క్యూలు చేస్తుంది. రెండవది, కన్స్యూమర్, థ్రెడ్ టేక్ పద్ధతిని ఉపయోగించి క్యూ నుండి ఎలిమెంట్‌లను రీడ్ చేస్తుంది మరియు వాటిని కన్సోల్‌లో ప్రదర్శిస్తుంది. మూలకాల క్రమం క్యూలో సహజమైనది.

import java.util.concurrent.*;
 
public class ArrayBlockingQueueExample {
 
   private BlockingQueue<Integer> blockingQueue;
   private final Integer[]  myArray = {1,2,3,4,5};
  
       public ArrayBlockingQueueExample ()
       { blockingQueue = new ArrayBlockingQueue<Integer>(1, true);
           (new Thread(new Producer())).start();
           (new Thread(new Consumer())).start();
       }
 
       class Producer implements Runnable
       {
           public void run() {
               try {
                   int counter = 0;
                   for (int i=0; i < myArray.length; i++) {
                       blockingQueue.put(myArray[i]);
                       if (counter++ < 2)
                           Thread.sleep(3000);
                   } blockingQueue.put(-1);
               }
               catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }
 
       class Consumer implements Runnable
       {
           public void run() {
               try {
                   Integer message = 0;
                   while (!((message = blockingQueue.take()).equals(-1)))
                       System.out.println(message);
               } catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }
 
       public static void main(String[] args) {
           new ArrayBlockingQueueExample();
       }
   }

అవుట్‌పుట్ అనేది సహజ క్రమంలో క్యూ; మొదటి రెండు అంశాలు ఆలస్యంతో కనిపిస్తాయి. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము

ముగింపులు

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