ஜாவா வரிசை இடைமுகம் மற்றும் அதன் செயலாக்கங்கள்

இங்கே நாம் ஜாவா வரிசை இடைமுகத்தைப் பற்றி விவாதிக்கப் போகிறோம். வரிசை தரவு அமைப்பு என்ன, ஜாவாவில் அது எவ்வாறு குறிப்பிடப்படுகிறது, எல்லா வரிசைகளுக்கும் என்ன முறைகள் மிக முக்கியமானவை என்பதை நீங்கள் கண்டுபிடிப்பீர்கள் . மேலும், ஜாவா மொழியில் வரிசையின் செயலாக்கங்கள் என்ன. அதன் பிறகு, மிக முக்கியமான செயலாக்கங்களை நாங்கள் கூர்ந்து கவனித்து, அவற்றை எடுத்துக்காட்டுகளுடன் கற்றுக்கொள்கிறோம்.

வரிசை தரவு அமைப்பு

ஒரு வரிசை என்பது ஒரு நேரியல் சுருக்க தரவு கட்டமைப்பாகும், இது குறிப்பிட்ட செயல்பாடுகளை வரிசைப்படுத்துகிறது - ஃபர்ஸ்ட் இன் ஃபர்ஸ்ட் அவுட் (FIFO). அதாவது, கட்டமைப்பின் முடிவில் மட்டுமே நீங்கள் ஒரு உறுப்பை (அல்லது என்கியூ, வரிசையில் வைக்கவும்) சேர்க்கலாம், மேலும் ஒரு உறுப்பை அதன் தொடக்கத்தில் இருந்து மட்டுமே (வரிசை அல்லது வரிசையில் இருந்து அகற்றவும்) எடுக்கலாம். வரிசை தரவு கட்டமைப்பை நீங்கள் மிக எளிதாக கற்பனை செய்யலாம். இது நிஜ வாழ்க்கையில் வரிசையாகவோ அல்லது வாடிக்கையாளர்களின் வரிசையாகவோ தெரிகிறது. முதலில் வந்த வாடிக்கையாளருக்கே முதலில் சேவை வழங்கப்படும். மெக்டொனால்ட்ஸ் அல்லது வேறு இடங்களில் நான்கு பேர் வரிசையில் இருந்தால், முதலில் வரிசையில் நிற்கும் நபர் முதலில் கடையைப் பெறுவார். புதிய வாடிக்கையாளர் வந்தால், ஹாம்பர்கர்களைப் பெறும் வரிசையில் 5வது இடத்தில் இருப்பார். எனவே, ஒரு வரிசையுடன் பணிபுரியும் போது, ​​முடிவில் புதிய கூறுகள் சேர்க்கப்படுகின்றன, மேலும் நீங்கள் ஒரு உறுப்பைப் பெற விரும்பினால், அது ஆரம்பத்தில் இருந்து எடுக்கப்படும். கிளாசிக்கல் வரிசை தரவு கட்டமைப்பு வேலையின் முக்கிய கொள்கை இதுவாகும்.

ஜாவாவில் வரிசை

ஜாவாவில் வரிசை என்பது ஒரு இடைமுகம். ஆரக்கிள் ஆவணங்களின்படி, வரிசை இடைமுகத்தில் 2 சூப்பர் இன்டர்ஃபேஸ்கள், வரிசையில் இருந்து பெறப்பட்ட 4 வெவ்வேறு இடைமுகங்கள் மற்றும் வகுப்புகளின் மிகவும் ஈர்க்கக்கூடிய பட்டியல் உள்ளது. இதற்கு என்ன அர்த்தம்? முதலில், ஜாவா வரிசையானது சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாகும் மற்றும் சேகரிப்பு இடைமுகத்தை செயல்படுத்துகிறது. எனவே இது செருகல், நீக்குதல் மற்றும் பல போன்ற சேகரிப்பு இடைமுகத்தின் அனைத்து முறைகளையும் ஆதரிக்கிறது. "ஒவ்வொரு வளையத்திற்கும்" அறிக்கையின் இலக்காக ஒரு பொருளை அனுமதிக்கும் இட்டரபிள் இடைமுகத்தை வரிசை செயல்படுத்துகிறது.

வரிசை முறைகள் ஜாவா

வரிசை பல முறைகளை அறிவிக்கிறது. இடைமுகத்தின் முறைகளாக, வரிசையை செயல்படுத்தும் அனைத்து வகுப்புகளிலும் அவை குறிப்பிடப்பட வேண்டும். மிக முக்கியமான வரிசை முறைகள், ஜாவா:

• பூலியன் சலுகை() - முடிந்தால் வரிசையில் புதிய உறுப்பைச் செருகும்
• பூலியன் சேர்(E e) - முடிந்தால் வரிசையில் புதிய உறுப்பைச் செருகும். வெற்றியின் பட்சத்தில் உண்மை எனத் திருப்பி, இடமில்லாமல் இருந்தால், சட்டத்திற்குப் புறம்பானது.
• ஆப்ஜெக்ட் வாக்கெடுப்பு() - தலையிலிருந்து ஒரு உறுப்பை மீட்டெடுத்து நீக்குகிறது. வரிசை காலியாக இருந்தால் பூஜ்யமாகத் திரும்பும்.
• பொருள் அகற்று() - வரிசையின் தலையிலிருந்து ஒரு உறுப்பை மீட்டெடுத்து நீக்குகிறது.
• ஆப்ஜெக்ட் பீக்() - மீட்டெடுக்கிறது, ஆனால் வரிசையின் தலையிலிருந்து ஒரு உறுப்பை அகற்றாது. வரிசை காலியாக இருந்தால் பூஜ்யமாகத் திரும்பும்.
• பொருள் உறுப்பு() – மீட்டெடுக்கிறது, ஆனால் வரிசையின் தலையிலிருந்து ஒரு உறுப்பை அகற்றாது.

ஜாவா வரிசையின் துணை இடைமுகங்கள்

வரிசை இடைமுகம் 4 துணை இடைமுகங்களால் பெறப்படுகிறது - BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E> . நீங்கள் அவற்றை 3 குழுக்களாகப் பிரிக்கலாம்: Deques, Blocking Queues மற்றும் Transfer Queues with BlockingDeque இரண்டையும் முதலில் சேர்ந்தது. இந்தக் குழுக்களைப் பற்றி ஒரு பார்வை பார்ப்போம்.

Deques

Deque என்பது D ouble- E nded Q ueue என்று பொருள்படும் மற்றும் தரவை ஒரு வரிசையாக (முதல்-இன்-ஃபர்ஸ்ட்-அவுட்/FIFO) அல்லது தலையில் இருந்து ஸ்டாக் (கடைசி-இன்-) எனப்படும் மற்றொரு பிரபலமான தரவுக் கட்டமைப்பாக சேர்ப்பது அல்லது அகற்றுவதை ஆதரிக்கிறது. முதல்-வெளியே/LIFO). Deque இடைமுகத்தை செயல்படுத்தும் வகுப்புகள்: ArrayDeque, ConcurrentLinkedDeque, LinkedBlockingDeque, LinkedList.

வரிசைகளைத் தடுப்பது

தடுக்கும் வரிசை என்பது இரண்டு நிகழ்வுகளில் ஒரு நூலைத் தடுக்கும் வரிசை:

• நூல் வெற்று வரிசையில் இருந்து உறுப்புகளைப் பெற முயற்சிக்கிறது
• நூல் முழு வரிசையில் கூறுகளை வைக்க முயற்சிக்கிறது

ஒரு நூல் வெற்று வரிசையில் இருந்து பொருட்களைப் பெற முயற்சிக்கும் போது, ​​வேறு ஏதாவது நூல் உருப்படிகளை வரிசையில் வைக்கும் வரை காத்திருக்கிறது. இதேபோல், ஒரு நூல் ஒரு முழு வரிசையில் உறுப்புகளை வைக்க முயற்சிக்கும் போது, ​​உறுப்புகளுக்கு இலவச இடத்தைப் பெற, வேறு சில நூல்கள் வரிசையிலிருந்து உறுப்புகளை எடுக்கும் வரை காத்திருக்கிறது. நிச்சயமாக, "முழு வரிசை" என்ற கருத்து, வரிசை வரையறுக்கப்பட்ட அளவைக் கொண்டிருப்பதைக் குறிக்கிறது, இது வழக்கமாக கட்டமைப்பாளரில் குறிப்பிடப்படுகிறது. நிலையான தடுப்பு வரிசைகளில் LinkedBlockingQueue, SynchronousQueue மற்றும் ArrayBlockingQueue ஆகியவை அடங்கும். BlockingQueue இடைமுகத்தின் வகுப்புகளை செயல்படுத்துதல் : ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, PriorityBlockingQueue, SynchronousQueue. BlockingDequeBlockingQueue க்கான துணை இடைமுகம். BlockingQueue போன்ற BlockingDeque தடுக்கும் வரிசை, ஆனால் இருதரப்பு. எனவே இது Deque இடைமுகத்தின் பண்புகளை பெறுகிறது. இது மல்டி த்ரெட் செயல்படுத்தலை நோக்கியது, பூஜ்ஜிய கூறுகளை அனுமதிக்காது மற்றும் திறன் குறைவாக இருக்கலாம். BlockingDeque இடைமுகத்தின் செயலாக்கங்கள் வரிசை காலியாக இருந்தால் உறுப்புகளைப் பெறுவதையும், அது நிரம்பியிருந்தால் வரிசையில் ஒரு உறுப்பைச் சேர்ப்பதையும் தடுக்கிறது.

பரிமாற்ற வரிசைகள்

TransferQueue இடைமுகம் BlockingQueue இடைமுகத்தை நீட்டிக்கிறது. இருப்பினும், BlockingQueue இடைமுக வரிசைகளை செயல்படுத்துவதைப் போலல்லாமல், வரிசை காலியாக இருந்தால் (படித்தல்), அல்லது வரிசை நிரம்பியிருந்தால் (எழுதுதல்), TransferQueue இடைமுக வரிசைகள் மற்றொரு ஸ்ட்ரீம் உறுப்பை மீட்டெடுக்கும் வரை எழுதும் ஸ்ட்ரீமைத் தடுக்கும். இதற்கு பரிமாற்ற முறையைப் பயன்படுத்தவும். வேறு வார்த்தைகளில் கூறுவதானால், BlockingQueue ஐ செயல்படுத்துவது தயாரிப்பாளரால் உருவாக்கப்பட்ட உறுப்பு வரிசையில் இருக்க வேண்டும் என்று உத்தரவாதம் அளிக்கிறது, அதே நேரத்தில் TransferQueue ஐ செயல்படுத்துவது உற்பத்தியாளர் உறுப்பு நுகர்வோரால் "பெறப்பட்டது" என்று உத்தரவாதம் அளிக்கிறது. TransferQueue இடைமுகத்தின் ஒரே ஒரு அதிகாரப்பூர்வ Java செயல்படுத்தல் உள்ளது - LinkedTransferQueue.

ஜாவா வரிசை செயலாக்கங்கள்

வரிசை இடைமுகத்தை செயல்படுத்தும் பல வகுப்புகள் உள்ளன:

• வரிசை ஜாவா 8 ஆவணங்களின்படி சுருக்க வரிசை , சில வரிசை செயல்பாடுகளின் அடிப்படை செயலாக்கங்களை இந்த சுருக்க வகுப்பு வழங்குகிறது. இது பூஜ்ய கூறுகளை அனுமதிக்காது. வரிசை கிளாசிக்கல் ஆஃபர் , வாக்கெடுப்பு , மற்றும் பீக் ஆகியவற்றின் அடிப்படையில் மேலும் 3 முறைகள் சேர்க்க, நீக்க மற்றும் உறுப்பு உள்ளது . இருப்பினும் தவறான அல்லது பூஜ்ய வருமானம் மூலம் தோல்வியைக் குறிப்பிடுவதற்குப் பதிலாக விதிவிலக்குகளை வீசுகிறார்கள்.
• ArrayBlockingQueue - ஒரு வரிசையால் ஆதரிக்கப்படும் நிலையான அளவு FIFO தடுப்பு வரிசை
• ArrayDeque — Deque இடைமுகத்தின் மறுஅளவிடத்தக்க வரிசை செயல்படுத்தல்
• ConcurrentLinkedDeque - இணைக்கப்பட்ட முனைகளின் அடிப்படையில் வரம்பற்ற ஒரே நேரத்தில் டிக்யூ.
• ConcurrentLinkedQueue - இணைக்கப்பட்ட முனைகளின் அடிப்படையில் வரம்பற்ற நூல்-பாதுகாப்பான வரிசை.
• DelayQueue — ஒரு குவியலால் ஆதரிக்கப்படும் நேர அடிப்படையிலான திட்டமிடல் வரிசை
• LinkedBlockingDeque — Deque இடைமுகத்தின் ஒரே நேரத்தில் செயல்படுத்தல்.
• LinkedBlockingQueue - இணைக்கப்பட்ட முனைகளால் ஆதரிக்கப்படும் விருப்பமான FIFO தடுப்பு வரிசை
• LinkedList — பட்டியல் மற்றும் Deque இடைமுகங்களின் இரட்டை-இணைக்கப்பட்ட பட்டியல் செயல்படுத்தல். அனைத்து விருப்ப பட்டியல் செயல்பாடுகளையும் செயல்படுத்துகிறது, மேலும் அனைத்து உறுப்புகளையும் (பூஜ்ய உட்பட) அனுமதிக்கிறது
• LinkedTransferQueue - இணைக்கப்பட்ட முனைகளின் அடிப்படையில் வரம்பற்ற பரிமாற்ற வரிசை
• PriorityBlockingQueue — ஒரு குவியலால் ஆதரிக்கப்படும் வரம்பற்ற தடுப்பு முன்னுரிமை வரிசை
• PriorityQueue — குவியல் தரவு கட்டமைப்பின் அடிப்படையில் ஒரு முன்னுரிமை வரிசை
• SynchronousQueue - ஒரு தடுப்பு வரிசை, இதில் ஒவ்வொரு செருகும் செயல்பாடும் மற்றொரு நூல் மூலம் தொடர்புடைய அகற்றும் செயல்பாட்டிற்காக காத்திருக்க வேண்டும், மேலும் நேர்மாறாகவும்.

LinkedList, ArrayBlockingQueue மற்றும் PriorityQueue ஆகியவை மிகவும் பிரபலமான செயலாக்கங்கள். அவற்றைப் பார்த்து, சிறந்த புரிதலுக்கு சில உதாரணங்களைச் செய்வோம்.

இணைக்கப்பட்ட பட்டியல்

ஜாவாவில் உள்ள Class LinkedList பட்டியல் மற்றும் Deque இடைமுகங்களை செயல்படுத்துகிறது. எனவே, இது லிஸ்ட் மற்றும் டிக்யூவின் கலவையாகும், இது இரு வழி வரிசையாகும், இது இருபுறமும் உள்ள உறுப்புகளைச் சேர்ப்பதையும் அகற்றுவதையும் ஆதரிக்கிறது. ஜாவாவில், லிங்க்ட்லிஸ்ட் என்பது இருமுறை இணைக்கப்பட்ட பட்டியல்: பட்டியலின் ஒவ்வொரு உறுப்பும் நோட் என்று அழைக்கிறது மற்றும் ஒரு பொருளையும், முந்தைய மற்றும் அடுத்த இரண்டு அண்டை பொருள்களுக்கான குறிப்புகளையும் கொண்டுள்ளது. நினைவகத்தைப் பயன்படுத்துவதில் LinkedList மிகவும் பயனுள்ளதாக இல்லை என்று நீங்கள் கூறலாம். அது உண்மைதான், ஆனால் செயல்பாடுகளைச் செருகுவதற்கும் நீக்குவதற்கும் இந்தத் தரவு அமைப்பு பயனுள்ளதாக இருக்கும். இருப்பினும், நீங்கள் அவர்களுக்கு இட்டேட்டர்களைப் பயன்படுத்தினால் மட்டுமே இது நடக்கும் (இந்த விஷயத்தில் இது நிலையான நேரத்தில் நிகழ்கிறது). குறியீட்டின் மூலம் அணுகல் செயல்பாடுகள் முடிவின் தொடக்கத்திலிருந்து (எது அருகில் உள்ளதோ) விரும்பிய உறுப்புக்குத் தேடுவதன் மூலம் செய்யப்படுகிறது. இருப்பினும், உறுப்புகளுக்கு இடையில் குறிப்புகளை சேமிப்பதற்கான கூடுதல் செலவுகள் பற்றி மறந்துவிடாதீர்கள். எனவே, லிங்க்டுலிஸ்ட் என்பது ஜாவாவில் மிகவும் பிரபலமான வரிசை செயலாக்கமாகும். இது பட்டியல் மற்றும் Deque இன் செயல்படுத்தல் ஆகும், மேலும் இது பூஜ்யம் உட்பட எந்தவொரு பொருட்களையும் கொண்ட இருதரப்பு வரிசையை உருவாக்க அனுமதிக்கிறது. LinkedList என்பது உறுப்புகளின் தொகுப்பாகும்.

இணைக்கப்பட்ட பட்டியல் கட்டமைப்பாளர்கள்

அளவுருக்கள் இல்லாத LinkedList() வெற்று பட்டியலை உருவாக்க பயன்படுகிறது. LinkedList(தொகுப்பு<? நீட்டிக்கிறது E> c) என்பது குறிப்பிட்ட சேகரிப்பின் கூறுகளைக் கொண்ட பட்டியலை உருவாக்குவதற்காக, அவை சேகரிப்பின் மறுதொடக்கத்தால் திருப்பி அனுப்பப்படும்.

முக்கிய இணைக்கப்பட்ட பட்டியல் முறைகள்:

• add(E உறுப்பு) இந்தப் பட்டியலின் முடிவில் குறிப்பிட்ட உறுப்பைச் சேர்க்கிறது;
• add(int index, E உறுப்பு) குறிப்பிட்ட நிலைக் குறியீட்டில் உறுப்பைச் செருகுகிறது;
• get(int index) இந்த பட்டியலில் குறிப்பிட்ட நிலையில் உள்ள உறுப்பை வழங்கும்;
• அகற்று(int index) நிலை குறியீட்டில் இருக்கும் உறுப்பை நீக்குகிறது;
• remove(Object o) இந்த பட்டியலில் இருந்து ?o உறுப்பின் முதல் நிகழ்வை நீக்குகிறது.
• remove() பட்டியலின் முதல் உறுப்பை மீட்டெடுத்து நீக்குகிறது.
• addFirst(), addLast() பட்டியலின் ஆரம்பம்/முடிவில் ஒரு உறுப்பைச் சேர்க்கவும்
• clear() பட்டியலிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது
• பட்டியலானது o உறுப்பைக் கொண்டிருந்தால், contains(Object o) உண்மை என்பதைத் தரும்.
• indexOf(Object o) ஆனது o உறுப்பின் முதல் நிகழ்வின் குறியீட்டை அல்லது பட்டியலில் இல்லை என்றால் -1 ஐ வழங்கும்.
• தொகுப்பு (int index, E உறுப்பு) குறியீட்டு நிலையில் உள்ள உறுப்பை உறுப்புடன் மாற்றுகிறது
• அளவு()பட்டியலில் உள்ள உறுப்புகளின் அளவை வழங்குகிறது.
• toArray() ஆனது பட்டியலின் அனைத்து உறுப்புகளையும் முதல் முதல் கடைசி உறுப்பு வரை கொண்ட ஒரு வரிசையை வழங்குகிறது.
• பாப்() அடுக்கில் இருந்து ஒரு உறுப்பைத் தோன்றும் (பட்டியலினால் குறிப்பிடப்படுகிறது)
• புஷ்(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 contains(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

ArrayBlockingQueue இன் உள் தரவு அமைப்புஉறுப்புகளை சேமிக்க ஒரு வட்ட வரிசையை அடிப்படையாகக் கொண்டது. வரிசையின் வால் பகுதியில் புதிய உறுப்புகள் செருகப்பட்டால், பிரித்தெடுத்தல் செயல்பாடுகள் வரிசையின் தலையிலிருந்து ஒரு உறுப்பைத் திருப்பியளித்தால், இது ஒரு பொதுவான வரிசை (FIFO) ஆகும். ஒருமுறை உருவாக்கப்பட்ட வரிசை திறனை மாற்ற முடியாது. ஒரு முழு வரிசையில் ஒரு உறுப்பைச் செருக (வைக்க) முயற்சிகள் ஓட்டத்தைத் தடுக்க வழிவகுக்கும்; வெற்று வரிசையில் இருந்து ஒரு உறுப்பை எடுக்க முயற்சிப்பதும் நூலைத் தடுக்கிறது. நாம் முன்பே கூறியது போல், இந்த வரிசை வட்டமானது. அதாவது வரிசையின் முதல் மற்றும் கடைசி கூறுகள் தர்க்கரீதியாக அருகருகே கையாளப்படுகின்றன. ஒவ்வொரு முறையும் நீங்கள் எலிமெண்டோவை வரிசையில் வைக்கும்போது அல்லது அதை வரிசையிலிருந்து அகற்றும்போது, ​​தலை மற்றும் வால் உறுப்புகளின் குறியீடுகளை வரிசை முன்னேற்றுகிறது. சில குறியீடுகள் வரிசையின் கடைசி உறுப்பை முன்னேற்றினால், அது 0 இலிருந்து மீண்டும் தொடங்குகிறது. எனவே, தலையை அகற்றும் போது (வழக்கமான வரிசையைப் போல) வரிசை அனைத்து உறுப்புகளையும் மாற்ற வேண்டியதில்லை. இருப்பினும், நடுவில் இருந்து ஒரு உறுப்பை அகற்றினால் (Iterator.remove ஐப் பயன்படுத்தி), உறுப்புகள் மாற்றப்படும். ArrayBlockingQueue , தயாரிப்பாளர்கள் (உறுப்புகளைச் செருகுதல்) மற்றும் நுகர்வோர் (உறுப்புகளைப் பிரித்தெடுத்தல்) ஆகியவற்றின் காத்திருப்பு ஓட்டங்களை ஒழுங்குபடுத்த, கட்டமைப்பாளரில் நியாயமான அளவுருவுடன் கூடிய கூடுதல் நியாயமான கொள்கையை ஆதரிக்கிறது . இயல்பாக, ஆர்டருக்கு உத்தரவாதம் இல்லை. இருப்பினும் "fair == true" என்று வரிசை உருவாக்கப்பட்டால், ArrayBlockingQueue வகுப்பின் செயலாக்கம் FIFO வரிசையில் நூல் அணுகலை வழங்குகிறது. சமபங்கு பொதுவாக அலைவரிசையை குறைக்கிறது, ஆனால் ஏற்ற இறக்கத்தை குறைக்கிறது மற்றும் வளங்கள் தீர்ந்து போவதை தடுக்கிறது.

ArrayBlockingQueue வகுப்பு கன்ஸ்ட்ரக்டர்கள்

• ArrayBlockingQueue (int திறன்) நிலையான திறன் மற்றும் இயல்புநிலை அணுகல் கொள்கையுடன் வரிசையை உருவாக்குகிறது.
• ArrayBlockingQueue (int திறன், boolean fair) ஒரு நிலையான திறன் மற்றும் ஒரு குறிப்பிட்ட அணுகல் கொள்கையுடன் வரிசையை உருவாக்குகிறது.
• 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 கருத்தை பின்பற்றுகிறது.
• ஜாவா வரிசையானது சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாகும் மற்றும் சேகரிப்பு இடைமுகத்தை செயல்படுத்துகிறது. எனவே இது செருகல், நீக்குதல் மற்றும் பல போன்ற சேகரிப்பு இடைமுகத்தின் அனைத்து முறைகளையும் ஆதரிக்கிறது.
• வரிசையின் மிகவும் அடிக்கடி பயன்படுத்தப்படும் செயலாக்கங்கள் LinkedList, ArrayBlockingQueue மற்றும் PriorityQueue ஆகும்.
• முன்னுரிமை வரிசையின் கூறுகள் அவற்றின் இயற்கையான வரிசைமுறையின்படி அல்லது வரிசை கட்டும் நேரத்தில் வழங்கப்படும் ஒப்பீட்டாளரால் வரிசைப்படுத்தப்படுகின்றன, இது எந்தக் கட்டமைப்பாளர் பயன்படுத்தப்படுகிறது என்பதைப் பொறுத்து.
• BlockingQueues இல் ஏதேனும் பூஜ்ய செயல்பாடு செய்யப்பட்டால், NullPointerException தூக்கி எறியப்படும்.