Vejledning til Java-køgrænsefladen

1. Introduktion

I denne vejledning diskuterer vi Java'er interface.

Først skal vi tage en kigge ved hvad en gør, og nogle af dens kernemetoder. Derefter dykker vi ned i et antal implementeringer, som Java leverer som standard.

Endelig vil vi tale om trådsikkerhed, inden vi pakker det hele sammen.

2. Visualisering af køen

Lad os starte med en hurtig analogi.

Forestil dig, at vi lige har åbnet vores første forretning - en hotdogsstand. Vi ønsker at betjene vores nye potentielle kunder på den mest effektive måde for vores mindre virksomhed; en ad gangen. Først beder vi dem om at danne en ordnet linje foran vores stand med nye kunder, der slutter sig bagtil. Takket være vores organisationsevner kan vi nu distribuere vores velsmagende hotdogs på en retfærdig måde.

Køer i Java fungerer på en lignende måde. Når vi erklærer vores Kø, vi kan tilføje nye elementer på bagsiden og fjerne dem fra forsiden.

Faktisk, mest Køer vi støder på i Java arbejde i dette første ind, først ud måde - ofte forkortet til FIFO.

Der er dog en undtagelse, som vi vil berøre senere.

3. Kernemetoder

Det erklærer en række metoder, der skal kodes af alle implementeringsklasser. Lad os skitsere et par af de mere vigtigedem nu:

  1. tilbud() - Indsætter et nyt element på
  2. afstemning()- Fjerner et element fra forsiden af
  3. kigge () Inspicerer elementet foran på Kø, uden at fjerne det

4. AbstraktKue

AbstraktKue er enklest muligt implementering, som Java giver. Det inkluderer en skeletimplementering af nogle af grænseflades metoder, eksklusive tilbud.

Når vi opretter en brugerdefineret kø udvide AbstraktKue klasse,vi skal give en implementeringaf tilbud metode hvilket gør ikke tillad indsættelse af nul-elementer.

Derudover vi skal give metoderne kig, afstemning, størrelse, og java.util'S iterator.

Lad os sammensætte en simpel implementering ved brug af AbstraktKue.

Lad os først definere vores klasse med en LinkedList at gemme vores elementer:

offentlig klasse CustomBaeldungQueue udvider AbstractQueue {private LinkedList-elementer; offentlig CustomBaeldungQueue () {this.elements = ny LinkedList (); }}

Lad os derefter tilsidesætte de krævede metoder og angiv koden:

@Override public Iterator iterator () {return elements.iterator (); } @ Override public int-størrelse () {return elements.size (); } @Override offentligt boolsk tilbud (T t) {if (t == null) returnerer false; elements.add (t); returner sandt; } @ Override offentlig T-afstemning () {Iterator iter = elements.iterator (); T t = iter.next (); hvis (t! = null) {iter.remove (); returnere t; } returnere null; } @ Override public T peek () {return elements.getFirst (); }

Fremragende, lad os kontrollere, at det fungerer med en hurtig enhedstest:

customQueue.add (7); customQueue.add (5); int først = customQueue.poll (); int sekund = customQueue.poll (); assertEquals (7, første); assertEquals (5, sekund);

4. Undergrænseflader

Generelt interface er arvet af 3 hovedundergrænseflader. Blokering af køer, overførselskøerog Deques.

Tilsammen implementeres disse 3 grænseflader af langt størstedelen af ​​Java's tilgængelige Køer. Lad os tage et hurtigt kig på, hvad disse grænseflader er sat til at gøre.

4.1. Blokerende køer

Det BlockingQueue interface understøtter yderligere operationer, der tvinger tråde til at vente på afhængigt af den aktuelle tilstand. En tråd kan vent på at være ikke-tom, når du forsøger at hente den, eller at den bliver tom, når du tilføjer et nyt element.

Standard Blokerende køer omfatte LinkedBlockingQueue, SynchronousQueue, og ArrayBlockingQueue.

For mere information, gå over til vores artikel om Blokerende køer.

4.2. Overfør køer

Det TransferQueue interface udvider BlockingQueue interface men er skræddersyet til producent-forbruger mønster. Det styrer informationsstrømmen fra producent til forbruger, hvilket skaber modtryk i systemet.

Java leveres med en implementering af TransferQueue interface, LinkedTransferQueue.

4.3. Deques

Deque er forkortelse for Double-Ended Queue og er analog med et kort kort - elementer kan tages fra både starten og slutningen af Deque. Meget som det traditionelle Kø, det Deque giver metoder til at tilføje, hente og kigge på elementer, der holdes både øverst og nederst.

For en detaljeret vejledning om, hvordan Deque fungerer, se vores ArrayDeque artikel.

5. Prioritetskøer

Vi så tidligere, at de fleste af de Køer som vi støder på i Java følger FIFO-princippet.

En sådan undtagelse fra denne regel er PriorityQueue. Når nye elementer indsættes i PrioritetKø, de bestilles baseret på deres naturlige rækkefølge eller ved en defineret Komparator leveres, når vi konstruerer Prioritet.

Lad os se på, hvordan dette fungerer med en simpel enhedstest:

PriorityQueue integerQueue = ny PriorityQueue (); integerQueue.add (9); integerQueue.add (2); integerQueue.add (4); int først = integerQueue.poll (); int sekund = integerQueue.poll (); int tredje = integerQueue.poll (); assertEquals (2, første); assertEquals (4, anden); assertEquals (9, tredje);

På trods af rækkefølgen, hvor vores heltal blev føjet til Prioritet, det kan vi se hentningsrækkefølgen ændres i henhold til den naturlige rækkefølge af numrene.

Vi kan se, at det samme også gælder, når det anvendes Strenge:

PriorityQueue stringQueue = ny PriorityQueue (); stringQueue.add ("blåbær"); stringQueue.add ("æble"); stringQueue.add ("kirsebær"); Streng først = stringQueue.poll (); Streng sekund = stringQueue.poll (); Streng tredje = stringQueue.poll (); assertEquals ("æble", først); assertEquals ("blåbær", andet); assertEquals ("kirsebær", tredje);

6. Trådsikkerhed

Tilføjer emner til Køer er især nyttig i miljøer med flere tråde. EN kan deles mellem tråde og bruges til at blokere fremskridt, indtil der er ledig plads - hjælper os overvinde nogle almindelige problemer med flere tråde.

For eksempel skaber skrivning til en enkelt disk fra flere tråde ressourcestrid og kan føre til langsomme skrivetider. Oprettelse af en enkelt forfattertråd med en BlockingQueue kan afhjælpe dette problem og føre til meget forbedrede skrivehastigheder.

Heldigvis tilbyder Java ConcurrentLinkedQueue, ArrayBlockingQueueog ConcurrentLinkedDeque som er trådsikre og perfekte til multitrådede programmer.

7. Konklusion

I denne vejledning har vi taget et dybt dyk i Java interface.

For det første vi udforskede hvad en gør, samt implementeringer, som Java leverer.

Næste, vi kiggede på en Kø's sædvanlige FIFO - princip samt PriorityQueue der adskiller sig i sin rækkefølge.

Endelig, vi udforsket trådsikkerhed og hvor Køer kan bruges i et miljø med flere tråde.

Som altid er koden tilgængelig på GitHub.