வரிசை

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

ஜாவாவில் உள்ள வரிசைகள் இரண்டு இயக்கக் கொள்கைகளை ஆதரிக்கின்றன: FIFO மற்றும் LIFO .

FIFO (First In, First Out) கொள்கையானது வழக்கமான வரிசையை நிர்வகிக்கிறது - வரிசையில் சேர்க்கப்படும் முதல் உறுப்பு அதை விட்டு வெளியேறும் .

LIFO (லாஸ்ட் இன், ஃபர்ஸ்ட் அவுட்) கொள்கை ஒரு அடுக்கின் நடத்தையை விவரிக்கிறது - வரிசையில் கடைசியாக சேர்க்கப்பட்ட உறுப்பு முதலில் அதை விட்டு வெளியேறும் . எடுத்துக்காட்டாக, அட்டைகளின் அட்டையுடன் நீங்கள் இப்படித்தான் வேலை செய்கிறீர்கள்: நீங்கள் டெக்கின் அடிப்பகுதியை அடையும் வரையில் ஒரு நேரத்தில் மேலே உள்ள அட்டைகளை எடுத்துவிடுவீர்கள்.

ஜாவாவில் வரிசை படிநிலை இது போல் தெரிகிறது :

வரிசையில் 3 செயல்படுத்தல் வகுப்புகள் இருப்பதை இங்கே காணலாம் : LinkedList , ArrayDeque மற்றும் PriorityQueue . LinkedList மற்றும் ArrayDeque நேரடியாக வரிசையை அல்ல , ஆனால் Deque ஐ பெறுகின்றன .

Deque என்பது ஜாவா 6 இல் சேர்க்கப்பட்ட ஒரு இடைமுகம். இது வரிசைகளுக்குப் பயன்படும் பல முறைகளை உள்ளடக்கியது மற்றும் ஒரு வரிசையை இரட்டை முனை (அல்லது இருதரப்பு) வரிசையாகச் செயல்பட அனுமதிக்கிறது. அதாவது FIFOமற்றும்LIFOஆக இருக்கலாம்.

Deque இடைமுகத்தின் இரண்டு வழித்தோன்றல்களில் ஒன்று ArrayDeque ஆகும் . இரு முனைகளிலும் உள்ள உறுப்புகளைச் செருகவும் அகற்றவும் உதவும் இரட்டை முனை வரிசையை இது ஆதரிக்கிறது. இது தானாக அளவு வளரும் ஒரு மாறும் வரிசையாகும்.

வரிசையின் நேரடி வழித்தோன்றலான முன்னுரிமை வரிசை வகுப்பும் உள்ளது : இது Deque ஐ செயல்படுத்தும் வகுப்புகளை விட வித்தியாசமாக செயல்படுகிறது .

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

PriorityQueue<String> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(String::length));

priorityQueue.add("Andrew");
priorityQueue.add("John");
priorityQueue.add("Rob");

while (!priorityQueue.isEmpty()) {
   System.out.println(priorityQueue.remove());
}

இந்த எடுத்துக்காட்டை இயக்கினால், கன்சோலில் நீங்கள் பார்ப்பது இங்கே:

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

while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.remove());
}

Deque இடைமுகம் வரிசை முறைகளைப் பெறுகிறது மற்றும் அதன் சொந்த பல சுவாரஸ்யமான முறைகளைச் சேர்க்கிறது :

நடைமுறையில் உள்ள இந்த முறைகளில் சிலவற்றை இப்போது பார்க்கலாம்.

முதலில், வரிசையில் ஒரு உறுப்பைச் சேர்ப்போம்:

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); // Adds "Apple" to the end of the queue
        deque.addFirst("Orange"); // Adds "Orange" to the front of the queue
        deque.addLast("Pineapple"); // Adds "Pineapple" to the end of the queue
  
        System.out.println(deque);
    

இப்போது வரிசையில் இருந்து மதிப்புகளைப் பெறுவோம்:

	Deque<String> deque = new ArrayDeque<>();

	deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 

         
        System.out.println("The first element is: "+ deque.getFirst());
                          
        System.out.println("The last element is: " + deque.getLast());
                          
    }
    

இந்த குறியீடு வரிசையின் முதல் மற்றும் கடைசி உறுப்பைக் காட்டுகிறது.

         Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 
        deque.add("Lemon");

System.out.println(deque.pop()); // Get and remove the first element of the queue
System.out.println(deque.poll()); // Get and remove the first element of the queue

System.out.println(deque);
    

இந்த குறியீட்டை இயக்கினால், நாம் பெறுகிறோம்:

பாப்() மற்றும் கருத்துக் கணிப்பு() ஆகியவற்றுக்கு இடையேயான வித்தியாசம் என்னவென்றால், பட்டியல் காலியாக இருந்தால், பாப்() ஒரு NoSuchElementException ஐ வீசும் , ஆனால் கருத்துக் கணிப்பு() பூஜ்யத்தை வழங்கும் .

இப்போது நாம் pollFirst() மற்றும் pollLast() முறைகளைக் கருத்தில் கொள்வோம்.

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); 
        deque.addFirst("Orange"); 
        deque.addLast("Pineapple"); 
        deque.add("Lemon");

System.out.println(deque.pollFirst()); // Get and remove the first element of the queue
System.out.println(deque.pollLast()); // Get and remove the last element of the queue.
System.out.println(deque);
    

இரண்டு முறைகளும் வரிசையில் இருந்து ஒரு மதிப்பை திரும்பவும் அகற்றவும்.

இங்கே peekFirst() மற்றும் peekLast() முறைகளைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு:

Deque<String> friends = new ArrayDeque<>();

friends.add("John");
friends.add("Rob");
friends.add("Greg");
friends.add("Max");
friends.add("Oliver");

System.out.println("The first element is: " + friends.peekFirst());
System.out.println("The last element is: " + friends.peekLast());

System.out.println(friends);
    

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

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