ஜாவா டிக்யூ இடைமுகம்

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

வரிசை vs Deque

Deque என்பது ஒரு வித்தியாசமான வரிசை: வால் மற்றும் கோட்டின் தலையில் புதிய கூறுகளைச் சேர்க்கலாம். அகற்றும் அதே கதை: இந்த அமைப்பிலிருந்து கடைசி அல்லது முதல் உறுப்பை நீங்கள் அகற்றலாம். எனவே, இது ஸ்டாக் மற்றும் வரிசையின் கலவையாகத் தெரிகிறது. "டீக்" என்ற பெயருக்கு "இரட்டை முடிவு வரிசை" என்று பொருள். "Deque" என்பது அட்டைகளின் "டெக்" போல உச்சரிக்கப்படுகிறது, உங்களுக்கு என்ன தெரியுமா? இது ஒரு உண்மையான அட்டை அட்டைக்கு ஓரளவு ஒத்திருக்கிறது: அத்தகைய டெக்கின் கீழிருந்து அல்லது மேலே இருந்து நீங்கள் ஒரு அட்டையை எடுக்கலாம். சில நேரியல் கட்டமைப்பின் இரு பக்கங்களிலிருந்தும் கூறுகளைச் சேர்க்க அல்லது அகற்ற விரும்புகிறீர்களா? Deque ஐப் பயன்படுத்தவும். ஜாவா 8 அல்லது வேறு எந்த பதிப்பும் இதை ஆதரிக்கிறது. ஒரு பொதுவான லெகோ செங்கல் மற்றும் செங்கற்களால் செய்யப்பட்ட ஒரு நெடுவரிசை "கோபுரங்கள்" ஆகியவற்றை கற்பனை செய்து பாருங்கள். நீங்கள் கோபுரத்தின் மேல் அல்லது கீழே ஒரு புதிய செங்கல் சேர்க்க முடியும். நீங்கள் இருபுறமும் ஒரு செங்கலை அகற்றலாம். இங்கே எங்களிடம் ஒரு எடுத்துக்காட்டு உள்ளது: அனைத்து மஞ்சள் செங்கற்களையும் மேலேயும் அனைத்து சிவப்புகளையும் கீழே சேர்க்கிறோம். இந்த உதாரணத்தை ஜாவா குறியீட்டுடன் விரைவில் காண்பிப்போம். எனவே நீங்கள் ஒரு ஜாவா டீக்கின் இரு முனைகளிலிருந்தும் வரிசைப்படுத்தலாம் மற்றும் வரிசைப்படுத்தலாம், அதாவது வரிசை மற்றும் அடுக்காக ஒரு டீக்கைப் பயன்படுத்தலாம். ஜாவாவில் ஸ்டாக் பற்றி படிக்கவும்: ஜாவா ஸ்டேக் 101: ஸ்டாக் வகுப்பில் ஆராய்தல் ஜாவாவில் வரிசை பற்றி படிக்கவும்: ஜாவா வரிசை இடைமுகம் மற்றும் அதன் செயலாக்கங்கள்

Deque இன் அம்சங்கள்

• ஜாவாவில் உள்ள Deque என்பது ஒரு இடைமுகமாகும், இது செயலாக்கங்கள் மறுஅளவிடக்கூடிய வரிசையின் ஆதரவை வழங்குகிறது. எனவே உங்களிடம் கட்டுப்பாடுகள் இல்லாத திறன் வரிசை உள்ளது மற்றும் உங்கள் தேவைகளுக்கு ஏற்ப புதிய கூறுகளைச் சேர்க்கலாம்.
• பல நூல்கள் மூலம் ஒரே நேரத்தில் அணுகல் Deque ஆல் ஆதரிக்கப்படவில்லை
• வெளிப்புற ஒத்திசைவு இல்லாத பட்சத்தில் Deque நூல்-பாதுகாப்பானது அல்ல.
• அணிவரிசையில் பூஜ்ய கூறுகள் அனுமதிக்கப்படவில்லை.

Deque Java இடைமுக அறிவிப்பு

public interface Deque<E> extends Queue<E>

ஜாவா டெக்யூ முறைகள்

java.util.Deque என்பது ஜாவா வரிசை இடைமுகத்தை நீட்டிக்கும் மற்றும் இரட்டை முனை வரிசையைக் குறிக்கும் ஒரு இடைமுகமாகும். எனவே Deque உடன் பணிபுரியும் போது அனைத்து Java Queue முறைகளையும் பயன்படுத்தலாம். Deque ஸ்டாக் இடைமுகத்தை நீட்டிக்கவில்லை என்றாலும், புஷ் , பீக் மற்றும் பாப் போன்ற வழக்கமான ஸ்டாக் செயல்பாடுகளைச் செய்ய உதவும் முறைகளை Deque இடைமுகம் வரையறுக்கிறது .

• பூலியன் சேர்(உறுப்பு) Deque இன் வாலில் ஒரு உறுப்பை சேர்க்கிறது. வெற்றியின்போது உண்மையாகத் திரும்பும், தற்போது இடம் கிடைக்கவில்லை என்றால், IllegalStateExceptionஐ வீசுகிறது.
• addFirst(உறுப்பு) Deque இன் தலையில் ஒரு உறுப்பை சேர்க்கிறது.
• addLast(உறுப்பு) Deque இன் வாலில் ஒரு உறுப்பை சேர்க்கிறது.
• ஆஃபர்(உறுப்பு) வால் ஒரு உறுப்பைச் சேர்த்து, செருகுவது வெற்றிகரமாக இருந்ததா என்பதை விளக்க பூலியனை வழங்குகிறது.
• ஆஃபர்ஃபர்ஸ்ட்(உறுப்பு) தலையில் ஒரு உறுப்பைச் சேர்த்து, செருகல் வெற்றிகரமாக இருந்ததா என்பதை விளக்க பூலியனை வழங்குகிறது.
• offerLast(உறுப்பு) வால் பகுதியில் ஒரு உறுப்பைச் சேர்த்து, செருகுவது வெற்றிகரமாக இருந்ததா என்பதை விளக்க பூலியனை வழங்குகிறது.
• iterator() deque க்கு ஒரு iterator ஐ வழங்குகிறது.
• descendingIterator() இந்த dequeக்கான தலைகீழ் வரிசையைக் கொண்ட ஒரு மறு செய்கையை வழங்குகிறது.
• புஷ்(உறுப்பு) தலையில் ஒரு உறுப்பை சேர்க்கிறது.
• பாப்(உறுப்பு) தலையிலிருந்து ஒரு உறுப்பை அகற்றி, அதைத் திருப்பித் தருகிறது.
• removeFirst() தலையிலுள்ள உறுப்பை நீக்குகிறது.
• removeLast() வால் பகுதியில் உள்ள உறுப்பை நீக்குகிறது.
• கருத்துக் கணிப்பு () இந்த டிக்யூவால் குறிப்பிடப்படும் வரிசையின் தலையை மீட்டெடுக்கிறது மற்றும் நீக்குகிறது (வேறுவிதமாகக் கூறினால், இந்த டிக்யூவின் முதல் உறுப்பு), அல்லது இந்த டிக்யூ காலியாக இருந்தால் பூஜ்யமாக வழங்கும்.
• pollFirst() இந்த deque இன் முதல் உறுப்பை மீட்டெடுத்து நீக்குகிறது அல்லது இந்த deque காலியாக இருந்தால் பூஜ்யத்தை வழங்கும்.
• pollLast() இந்த deque இன் கடைசி உறுப்பை மீட்டெடுத்து நீக்குகிறது அல்லது இந்த deque காலியாக இருந்தால் பூஜ்யத்தை வழங்கும்.
• peek() இந்த டிக்யூவால் குறிப்பிடப்படும் வரிசையின் தலையை மீட்டெடுக்கிறது, ஆனால் அகற்றாது (வேறுவிதமாகக் கூறினால், இந்த deque இன் முதல் உறுப்பு), அல்லது இந்த deque காலியாக இருந்தால் பூஜ்யமாக வழங்கும்.
• peekFirst() இந்த deque இன் முதல் உறுப்பை மீட்டெடுக்கிறது, ஆனால் அகற்றாது, அல்லது இந்த deque காலியாக இருந்தால் பூஜ்யத்தை வழங்குகிறது.
• peekLast() இந்த deque இன் கடைசி உறுப்பை மீட்டெடுக்கிறது, ஆனால் அகற்றாது, அல்லது இந்த deque காலியாக இருந்தால் பூஜ்யத்தை வழங்குகிறது.

இங்கே கீழே உள்ள அட்டவணையில் அனைத்து முறைகளும் குழுக்களாக பிரிக்கப்பட்டுள்ளன. நீங்கள் பார்க்க முடியும் என, ஒரு உறுப்பு சேர்க்க மற்றும் நீக்க பல்வேறு முறைகள் உள்ளன. எடுத்துக்காட்டாக, removeFirst() மற்றும் pop() இரண்டும் deque இலிருந்து முதல் உறுப்பை நீக்குகிறது. இரண்டாவது அடுக்கிலிருந்து "வந்தது". அதாவது உங்கள் ArrayDeque ஐ அடுக்காக மட்டும் பயன்படுத்தினால், அகற்றுவதற்கு pop() ஐயும், சேர்க்க புஷ்() மற்றும் ஆய்வு செய்ய எட்டி() ஐயும் பயன்படுத்தவும். இது உங்கள் குறியீட்டை மற்ற டெவலப்பர்களுக்கு மிகவும் விவேகமானதாக மாற்றுகிறது.

Deque அமலாக்கங்கள்

Java Deque என்பது ஒரு இடைமுகம் மற்றும் Java Collections API இல் செயலாக்கங்களைக் கொண்டுள்ளது:

• java.util.LinkedList //பட்டியல் மற்றும் டீக் செயல்படுத்தல்
• java.util.ArrayDeque //Deque செயல்படுத்தல், ஜாவா நூலகம்

LinkedList வகுப்பானது, வரிசை அல்லது டிக்யூவை மாதிரியாக்க உள்நாட்டில் இரட்டை-இணைக்கப்பட்ட பட்டியலைப் பயன்படுத்துகிறது. ArrayDeque கிளாஸ் உறுப்புகளை ஒரு வரிசையில் உள்நாட்டில் சேமிக்கிறது. உறுப்புகளின் எண்ணிக்கை வரிசையின் அளவை விட அதிகமாக இருந்தால், ஒரு புதிய வரிசை ஒதுக்கப்படும், மேலும் அனைத்து உறுப்புகளும் நகர்த்தப்படும். அதாவது ArrayDeque தேவைகளால் வளர்கிறது.

ArrayDeque வகுப்பு

ArrayDeque <E> வகுப்பு என்பது ஒரு பொதுவான இரு திசை வரிசையாகும், இது AbstractCollection வகுப்பிலிருந்து செயல்பாட்டைப் பெறுகிறது மற்றும் Deque இடைமுகத்தைப் பயன்படுத்துகிறது. ArrayDeque ஆனது deque மற்றும் resizable-array ஐப் பயன்படுத்தும் வசதியை வழங்குகிறது. ஆரம்பத்தில், வரிசை அளவு 16 உடன் துவக்கப்பட்டது. இது இரு வழி வரிசையாக செயல்படுத்தப்படுகிறது, அங்கு அது இரண்டு சுட்டிகளை ஆதரிக்கிறது, அதாவது தலை மற்றும் வால். இது AbstractCollection வகுப்பைப் பெறுகிறது மற்றும் Deque இடைமுகத்தை செயல்படுத்துகிறது. ArrayDeque வகுப்பைப் பற்றிய முக்கியமான புள்ளிகள்:

• ArrayDeque இன் வால் மற்றும் தலையிலிருந்து உறுப்புகளைச் சேர்க்கலாம் அல்லது அகற்றலாம்
• பூஜ்ய கூறுகள் அனுமதிக்கப்படவில்லை
• வெளிப்புற ஒத்திசைவு இல்லாத நிலையில் ArrayDeque நூல் பாதுகாப்பானது அல்ல.
• ArrayDeque இல் திறன் கட்டுப்பாடுகள் இல்லை.

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

• ArrayDeque() ஒரு வெற்று வரிசையை உருவாக்குகிறது.
• ArrayDeque (சேகரிப்பு <? நீட்டிக்கிறது E> சேகரிப்பு) சேகரிப்பு கூறுகள் நிரப்பப்பட்ட வரிசையை உருவாக்குகிறது.
• ArrayDeque (int திறன்) ஆரம்ப திறன் திறன் கொண்ட ஒரு வரிசையை உருவாக்குகிறது . நீங்கள் ஆரம்ப திறனைக் குறிப்பிடவில்லை என்றால், இயல்புநிலை திறன் 16 ஆகும்.

Java Deque உதாரணம் — ArrayDeque

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

//enum with colors 
public enum Color {
   RED, YELLOW, BLUE;
}

//class for the standard Lego Brick. You can connect or disconnect the Brick, it has color   
public class LegoBrick {
   Color color;
   boolean isConnected;

   public void connect() {
       System.out.println("This brick is connected");
       this.isConnected = true;
   }

   public void disconnect() {
       System.out.println("Disconnected");
       isConnected = false;
   }

   public LegoBrick(Color color, boolean isConnected) {
       this.color = color;
       this.isConnected = isConnected;
   }

   public Color getColor() {
       return color;
   }

   public boolean isConnected() {
       return isConnected;
   }

   @Override
   public String toString() {
       return "LegoBrick{" +
              "color=" + color +
              ", isConnected=" + isConnected +
              '}';
   }
}

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

import java.util.ArrayDeque;
public class LegoTower {
   ArrayDeque<LegoBrick> myTower;
   int quantityOfReds;
   int quantityOfYellows;

   public void addBrickToTower(LegoBrick newLegoBrick) {
       if (newLegoBrick.getColor() == Color.YELLOW) {
           this.myTower.offerLast(newLegoBrick);
           quantityOfYellows++;
       }
	//we can use addFirst(e)/push(e) instead of offerFirst here 
       if (newLegoBrick.getColor() == Color.RED) {
           myTower.offerFirst(newLegoBrick);
           quantityOfReds++;
       }
   }

   public void removeBrickFromTower (LegoBrick legoBrick) {
       if (legoBrick.getColor() == Color.YELLOW) {
           this.myTower.removeLast();
           quantityOfYellows--;
       }
       if (legoBrick.getColor() == Color.RED) {
           myTower.removeFirst();
           quantityOfReds--;
       }
       legoBrick.isConnected = false;

   }

   public LegoTower(int quantityOfReds, int quantityOfYellows) {

       myTower = new ArrayDeque<>();
       this.quantityOfReds = quantityOfReds;
       this.quantityOfYellows = quantityOfYellows;
       for (int i = 0; i < quantityOfReds; i++) {
           LegoBrick redLegoBrick = new LegoBrick(Color.RED, false);
           myTower.addFirst(redLegoBrick);
           redLegoBrick.isConnected = true;
       }
       for (int i = 0; i < quantityOfYellows; i++) {
           LegoBrick yellowLegoBrick = new LegoBrick(Color.YELLOW, false);
           myTower.addLast(yellowLegoBrick);
           yellowLegoBrick.isConnected = true;
       }
   }

   public void setMyTower(ArrayDeque<legobrick> myTower) {
       this.myTower = myTower;
   }

   public void setQuantityOfReds(int quantityOfReds) {
       this.quantityOfReds = quantityOfReds;
   }

   public void setQuantityOfYellows(int quantityOfYellows) {
       this.quantityOfYellows = quantityOfYellows;
   }

   @Override
   public String toString() {
       return "LegoTower{" +
              "myTower=" + myTower +
              ", quantityOfReds=" + quantityOfReds +
              ", quantityOfYellows=" + quantityOfYellows +
              '}';
   }

   public void drawTower() {
       for (LegoBrick i : myTower) {
           System.out.println(i.color);
       }
   }
}


public class Main {
   public static void main(String[] args) {
       LegoBrick legoBrick1 = new LegoBrick(Color.YELLOW, false);
       legoBrick1.connect();
       System.out.println(legoBrick1.toString());
       legoBrick1.disconnect();
       System.out.println(legoBrick1.toString());
       LegoBrick legoBrick2 = new LegoBrick(Color.YELLOW, false);
       LegoBrick legoBrick3 = new LegoBrick(Color.RED, false);
       LegoBrick legoBrick4 = new LegoBrick(Color.RED, false);
       LegoBrick legoBrick5 = new LegoBrick(Color.YELLOW, false);

       LegoTower legoTower = new LegoTower(2, 5);
       System.out.println("my Initiated Lego Tower: ");
       legoTower.drawTower();
       legoTower.addBrickToTower(legoBrick1);
       legoTower.addBrickToTower(legoBrick2);
       legoTower.addBrickToTower(legoBrick3);
       legoTower.addBrickToTower(legoBrick4);
       legoTower.addBrickToTower(legoBrick5);
       System.out.println("My LegoTower after adding some elements: ");
       legoTower.drawTower();
       legoTower.removeBrickFromTower(legoBrick1);
       legoTower.removeBrickFromTower(legoBrick3);
       System.out.println("We removed one red and one yellow brick:");
       legoTower.drawTower();

   }

}

இந்த நிரலை இயக்குவதன் விளைவு:

my Initiated LegoTower:

RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
My LegoTower after adding some elements: 
RED
RED
RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
We removed one red and one yellow brick:
RED
RED
RED
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW
YELLOW

Process finished with exit code 0

பொறு, என்ன?? சிவப்பு நிறங்கள் ஏன் மேலே உள்ளன? இல்லை, அவர்கள் இல்லை. அவை முதலில் (கீழே) தொடங்கி கடைசி (மேல்) வரை கன்சோலுக்கு அச்சிடப்பட்டன. எனவே மேலே உள்ள செங்கற்களுடன் படத்தில் உள்ளதைப் போன்ற ஒன்றை நீங்கள் பார்க்க விரும்பினால், LegoTower வகுப்பின் டிராடவர் முறையை மாற்றலாம். இது மிகவும் எளிதான பணி!

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

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

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

நடைமுறையில் இந்த செயல்பாடுகளை முயற்சிப்போம். முதலில், ஜாவா லிங்க்டுலிஸ்ட் செயல்படுத்தல்: 3 கூறுகளைச் சேர்ப்பது, சரங்களின் லிங்க்ட் லிஸ்ட் உருவாக்குதல். பின்னர் ஒன்றை அகற்றவும், பின்னர் ஒன்றை நடுவில் சேர்க்கவும்.

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
//  LinkedList implementation in Java
       LinkedList<string> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println("my list after adding 3 elements:");
       System.out.println(linkedList);
       System.out.println("element #2 of my list:");
       System.out.println(linkedList.get(2));
       linkedList.remove(1);
       System.out.println("my list after removing #1:");
       System.out.println(linkedList);
       linkedList.add(1,"first");
       System.out.println("my list after adding an element in the middle");
       System.out.println(linkedList);
   }

இந்த நிரலை இயக்குவதன் விளைவு:

my list after adding 3 elements:
[my, favorite, book]
element #2 of my list:
book
my list after removing #1:
[my, book]
my list after adding an element in the middle
[my, first, book]