Interface ng Java Deque

Ang Java Deque ay isang istraktura ng data na pinagsasama ang isang ordinaryong Queue at Stack. Maaari kang magdagdag at mag-alis ng mga elemento kapwa sa ulo at sa buntot ng Deque. Sa "tradisyonal" na pila, magdagdag ka ng mga elemento sa buntot ng linya (pagkatapos ng huling elemento) at alisin ang mga elemento mula sa ulo ng pila. Ang prinsipyong ito ay tinatawag na First In First Out (FIFO) at gumagana ito tulad ng anumang karaniwang linya ng mga customer sa totoong buhay. Sa Java Queue ay isang Interface, isang bahagi ng Collections Framework. Mayroon ding mahalagang istraktura ng data na tinatawag na Stack, isang listahan na gumagana sa mga elemento sa ganap na baligtad na prinsipyo, LIFO — huling papasok, una sa labas. Ito ay katulad ng isang stack ng mga plato, ang pagdaragdag o pag-alis ay posible lamang sa itaas.

Pila vs Deque

Ang Deque ay medyo kakaibang uri ng Queue: maaari kang magdagdag ng mga bagong elemento kapwa sa buntot at sa ulo ng linya. Ang parehong kuwento sa pag-alis: maaari mong alisin ang huli o ang unang elemento mula sa istrukturang ito. Kaya naman, ito ay tila pinaghalong Stack at Queue. Ang pangalang "Deque" ay nangangahulugang "Double Ended Queue". Ang "Deque" ay binibigkas na parang "deck" ng mga baraha at alam mo kung ano? Ito ay medyo katulad ng isang tunay na deck ng mga card: maaari kang kumuha ng card mula sa ibaba o sa itaas ng naturang deck. Gustong magdagdag o mag-alis ng mga elemento mula sa magkabilang panig ng ilang linear na istraktura? Gamitin ang Deque. Sinusuportahan ito ng Java 8 o halos anumang iba pang bersyon. Isipin ang isang tipikal na lego brick at isang haligi na "mga tore" na gawa sa mga brick. Maaari kang magdagdag ng bagong brick sa tuktok ng tore o sa ibaba. Maaari mo ring alisin ang isang ladrilyo mula sa magkabilang panig. Narito mayroon kaming isang halimbawa: idinagdag namin ang lahat ng dilaw na brick sa itaas at lahat ng pula sa ibaba. Ipapakita namin ang halimbawang ito gamit ang Java code sa lalong madaling panahon. Kaya maaari kang mag-enqueue at mag-dequeue mula sa magkabilang dulo ng isang Java Deque, na nangangahulugan na maaari mong gamitin ang isang Deque bilang parehong queue at stack. Basahin ang tungkol sa Stack sa Java: Java Stack 101: Delving sa Stack Class Basahin ang tungkol sa Queue sa Java: Java Queue Interface at mga pagpapatupad nito

Mga katangian ni Deque

• Ang Deque sa Java ay isang Interface, na ang mga pagpapatupad ay nagbibigay ng suporta ng isang resizable array. Kaya mayroon kang isang hanay ng kapasidad na walang paghihigpit at maaari kang magdagdag ng mga bagong elemento ayon sa iyong mga pangangailangan.
• Ang sabay-sabay na pag-access ng maraming mga thread ay hindi sinusuportahan ng Deque
• Ang Deque ay hindi ligtas sa thread kung sakaling walang panlabas na pag-synchronize.
• Walang mga Null na elemento na pinapayagan sa array deque.

Deque Java Interface na deklarasyon

public interface Deque<E> extends Queue<E>

Mga Paraan ng Java Deque

Ang java.util.Deque ay isang Interface na nagpapalawak ng Java Queue Interface at kumakatawan sa isang double ended queue. Kaya maaari mong gamitin ang lahat ng mga pamamaraan ng Java Queue habang nagtatrabaho sa isang Deque. Sa kabila ng hindi pagpapalawak ng Deque sa interface ng Stack, ang interface ng Deque ay tumutukoy sa mga pamamaraan na nagbibigay-daan sa iyong gawin ang mga tipikal na operasyon ng stack tulad ng push , peek at pop .

• Ang boolean add(element) ay nagdaragdag ng elemento sa buntot ng Deque. Nagbabalik ng totoo sa tagumpay, naghagis ng IllegalStateException kung walang available na espasyo sa kasalukuyan.
• addFirst(element) ay nagdaragdag ng elemento sa ulo ng Deque.
• addLast(element) ay nagdaragdag ng elemento sa buntot ng Deque.
• offer(element) ay nagdaragdag ng elemento sa buntot at nagbabalik ng boolean upang ipaliwanag kung matagumpay ang pagpasok.
• offerFirst(element) ay nagdaragdag ng elemento sa head at nagbabalik ng boolean upang ipaliwanag kung matagumpay ang pagpasok.
• offerLast(element) ay nagdaragdag ng elemento sa buntot at nagbabalik ng boolean upang ipaliwanag kung matagumpay ang pagpasok.
• ang iterator() ay nagbabalik ng iterator para sa deque.
• descendingIterator() ay nagbabalik ng isang iterator na may reverse order para sa deque na ito.
• push(element) ay nagdaragdag ng elemento sa ulo.
• Tinatanggal ng pop(element) ang isang elemento mula sa ulo at ibinabalik ito.
• Tinatanggal ng removeFirst() ang elemento sa ulo.
• Tinatanggal ng removeLast() ang elemento sa buntot.
• Kinukuha at inaalis ng poll() ang ulo ng pila na kinakatawan ng deque na ito (sa madaling salita, ang unang elemento ng deque na ito), o nagbabalik ng null kung walang laman ang deque na ito.
• Kinukuha at inaalis ng pollFirst() ang unang elemento ng deque na ito, o nagbabalik ng null kung walang laman ang deque na ito.
• Kinukuha at inaalis ng pollLast() ang huling elemento ng deque na ito, o nagbabalik ng null kung walang laman ang deque na ito.
• peek() kinukuha, ngunit hindi inaalis, ang ulo ng queue na kinakatawan ng deque na ito (sa madaling salita, ang unang elemento ng deque na ito), o nagbabalik ng null kung walang laman ang deque na ito.
• Kinukuha ng peekFirst() , ngunit hindi inaalis, ang unang elemento ng deque na ito, o nagbabalik ng null kung walang laman ang deque na ito.
• Kinukuha ng peekLast() , ngunit hindi inaalis, ang huling elemento ng deque na ito, o nagbabalik ng null kung walang laman ang deque na ito.

Dito sa talahanayan sa ibaba ang lahat ng mga pamamaraan ay hinati ayon sa mga grupo. Tulad ng nakikita mo mayroong maraming iba't ibang mga paraan upang magdagdag at mag-alis ng isang elemento. Halimbawa, ang parehong removeFirst() at pop() ay nag-aalis ng unang elemento mula sa deque. Ang pangalawa ay "nagmula" mula sa stack. Ibig sabihin, kung gagamitin mo ang iyong ArrayDeque bilang stack lang, gamitin ang pop() para tanggalin, push() para magdagdag at silip() para suriin. Ginagawa nitong mas sensible ang iyong code para sa iba pang mga developer.

Mga Pagpapatupad ng Deque

Ang Java Deque ay isang interface at may mga pagpapatupad sa Java Collections API:

• java.util.LinkedList //List at Deque na pagpapatupad
• java.util.ArrayDeque //Pagpapatupad ng Deque, Java library

Gumagamit ang LinkedList class ng double-linked list sa loob upang magmodelo ng queue o deque. Iniimbak ng klase ng ArrayDeque ang mga elemento sa loob ng isang array. Kung ang bilang ng mga elemento ay lumampas sa dami ng array, isang bagong array ang inilalaan, at lahat ng mga elemento ay inilipat. Ibig sabihin, lumalaki ang ArrayDeque ayon sa mga pangangailangan.

klase ng ArrayDeque

Ang ArrayDeque <E> class ay isang pangkalahatang dalawang direksyon na pila, na nagmamana ng functionality mula sa AbstractCollection class at gamit ang Deque interface. Nagbibigay ang ArrayDeque ng pasilidad ng paggamit ng deque at resizable-array. Sa una, ang array ay pinasimulan na may sukat na 16. Ito ay ipinatupad bilang isang two-way na pila, kung saan sinusuportahan nito ang dalawang pointer, katulad ng ulo at buntot. Nagmana ito ng klase ng AbstractCollection at nagpapatupad ng interface ng Deque . Ang mahahalagang punto tungkol sa klase ng ArrayDeque ay:

• Maaari kang magdagdag o mag-alis ng mga elemento mula sa buntot at sa ulo ng ArrayDeque
• Ang mga null na elemento ay hindi pinapayagan
• Ang ArrayDeque ay hindi ligtas sa thread, sa kawalan ng panlabas na pag-synchronize.
• Ang ArrayDeque ay walang mga paghihigpit sa kapasidad.

ArrayDeque class Constructors

• Ang ArrayDeque() ay lumilikha ng isang walang laman na pila.
• Ang ArrayDeque (Collection <? Extends E> collection) ay lumilikha ng queue na puno ng mga elemento ng Collection collection.
• Ang ArrayDeque (int capacity) ay lumilikha ng isang pila na may paunang kapasidad na kapasidad. Kung hindi mo tinukoy ang paunang kapasidad, ang default na kapasidad ay 16.

Halimbawa ng Java Deque — ArrayDeque

Tandaan ang Halimbawa ng Lego Tower mula sa simula ng artikulo? Gumawa tayo ng klase para Bumuo ng isang-column Tower na gawa sa Lego Bricks. Ang mga brick ay maaaring pula, dilaw o asul. Ang aming panuntunan sa pagtatayo ng Tower: inilalagay namin ang pulang brick sa ibaba at dilaw na brick sa itaas. Halimbawa ng Big Java Deque

//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 +
              '}';
   }
}

Narito ang aming klase sa Tower. Nagsisimula kami ng isang tore. Ang pinasimulang tore ay depende sa dami ng pula at dilaw. Maaari tayong magdagdag ng ladrilyo sa tore o alisin ito. Nagdaragdag kami ng ladrilyo sa itaas kung ito ay dilaw at idagdag ito sa ibaba kung ito ay pula.

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

   }

}

Ang resulta ng pagpapatakbo ng program na ito:

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

Ano nga ulit?? Bakit nasa itaas ang mga pula? Hindi, hindi nila ginagawa. Nag-print lang sila sa consol simula sa una (ibaba) hanggang sa huli (itaas). Kaya kung gusto mong makakita ng isang bagay tulad ng sa larawan na may mga brick sa itaas, maaari mong baguhin ang paraan ng drawTower ng klase ng LegoTower. Ito ay isang napakadaling gawain!

LinkedList

Pinapanatili ng interface ng Listahan ang pagkakasunud-sunod ng pagdaragdag ng mga item at nagbibigay-daan sa pag-access sa item ayon sa index. Ang Deque ay isang two-way queue, at sinusuportahan nito ang pagdaragdag at pag-alis ng mga elemento mula sa magkabilang panig. Ang LinkedList ay pangunahing kilala bilang isang pagpapatupad ng Listahan, ngunit ipinapatupad din ng klase na ito ang Deque, at pinapayagan kaming lumikha ng isang bidirectional queue na binubuo ng anumang mga bagay kabilang ang null. Ang LinkList ay isang koleksyon ng mga elemento. Makikita natin ito sa source code ng klase, sa pagkakataong ito ay bigyang-pansin ang mga field: Dito nagdaragdag kami ng isang halimbawa, ngunit kung gusto mong matuto nang higit pa tungkol sa LinkedList, maligayang pagdating sa artikulong ito ng CodeGym .

Pagpapatupad ng naka-link na listahan sa Java, pagdaragdag at pag-alis ng mga elemento. Halimbawa

Subukan natin ang mga operasyong ito sa pagsasanay. Una, pagpapatupad ng Java LinkedList: paglikha ng LinkedList ng mga String, pagdaragdag doon ng 3 elemento. Pagkatapos ay alisin ang isa, pagkatapos ay magdagdag ng isa sa gitna.

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

Ang resulta ng pagpapatakbo ng program na ito:

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]