Lad os begynde med en Queue. Forestil dig en kø i en butik under et udsalg. Der er 10 personer; den første person står tættest på butikkens dør end de andre, og den 10. person står længst væk. Når den første person går ind i butikken, forlader personen køen, hvilket rykker hele køen frem med én person. Java Queue fungerer efter et meget lignende princip.

På denne måde kan du implementere forskellige programmer, hvor kølogikken er gennemtænkt. For eksempel implementering af et board med planer og opgaver.

Men først skal vi se på de grundlæggende metoder til at arbejde med en Queue.

Queue er et interface, som LinkedList-klassen arver fra, hvilket du allerede kender, så vi vil bruge denne implementering.

På denne måde bruger du interfacet som objektets type, men objektets implementering vil være LinkedList, fordi det er en specifik implementering af dette objekt. (Husk, at du ikke kan oprette objekter baseret på et interface).

Eksempel:

Example.java


              1234
            
// `LinkedList` as implementation of the `List` interface:
List<T> list = new LinkedList<>(); 
// `LinkedList` as implementation of the `Queue` interface:
Queue<T> queue = new LinkedList<>();

På denne måde kan du gøre vores applikation meget fleksibel ved at bruge forskellige implementeringer af den samme grænseflade.

Men lad os vende tilbage til metoderne til at arbejde med Queue.

Metoder

Nogle vigtige metoder i Queue-grænsefladen er:

add(element): tilføjer et element til køen, kaster en undtagelse hvis operationen ikke er mulig;
offer(element): tilføjer et element til køen, returnerer true hvis det lykkes eller false ellers.

Du kan bemærke, at disse metoder grundlæggende udfører det samme. Den væsentlige forskel er dog sikkerheden ved offer-metoden. Hvis et element ikke kan tilføjes korrekt, vil offer-metoden ikke kaste en undtagelse og vil ikke stoppe programmets udførelse.

Men i øjeblikket er denne egenskab ikke af stor interesse for os, da en almindelig Queue ikke er begrænset. Der findes dog en struktur kaldet BlockingQueue, som har en begrænsning på antallet af elementer; i dette tilfælde vil disse metoder have en mærkbar forskel.

Lad os se på et eksempel:

Main.java


              1234567891011121314
            
package com.example;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(2);
        queue.add("One");
        queue.add("Two");
        queue.add("Three");
        System.out.println("Queue: " + queue);
    }
}

Som du kan se, når du bruger add()-metoden og forsøger at tilføje et element, der ikke passer ind i køen, kaster programmet en fejl, hvilket uventet afslutter eksekveringen.

Lad os prøve den samme operation, men med en mere sikker metode — offer():

Main.java


              1234567891011121314
            
package com.example;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(2);
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        System.out.println("Queue: " + queue);
    }
}

Som du kan se, blev elementet ikke tilføjet til køen, men der blev heller ikke kastet en undtagelse. Derfor kan vi betragte det som om, vi håndterede fejlen elegant.

Du kan håndtere undtagelser på andre måder ved at bruge en struktur som try-catch, men det vil vi diskutere senere.

Fjernelsesmetoder

remove(): fjerner og returnerer elementet fra begyndelsen af køen, kaster en undtagelse hvis køen er tom;
poll(): fjerner og returnerer elementet fra begyndelsen af køen, returnerer null hvis køen er tom.

Disse metoder udfører præcist funktionen, som hvis første person i køen gik ind i butikken og forlod køen. Det er her, FIFO-princippet (First In, First Out) kommer i spil. Med andre ord, det element der blev tilføjet først til køen, vil være det første der fjernes.

Her kan du også observere forskellen mellem disse to metoder. Metoden poll() bruges oftere end metoden remove(), fordi den er mere sikker og ikke kaster undtagelser.

Lad os se på et eksempel:

Main.java


              123456789101112131415
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        System.out.println("Queue: " + queue);
        queue.remove();
        queue.remove();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Som du kan se, kaster programmet en NoSuchElementException, fordi vi forsøger at fjerne et element fra en tom kø.

For at undgå en sådan undtagelse er det bedre at bruge poll()-metoden:

Main.java


              123456789101112131415
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        System.out.println("Queue: " + queue);
        queue.poll();
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Nu har vi fjernet et element fra køen på en sikker måde, og der blev ikke kastet nogen undtagelse, da vi forsøgte at fjerne et element fra en tom liste.

At poll() returnerer null kan for eksempel bruges i et while()-loop.

Lad os se på et eksempel:

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (queue.poll() != null) {
            queue.poll();
        }
        System.out.println("Queue after removal operation: " + queue);
    }
}

På denne måde kan alle elementer fjernes fra køen ved hjælp af en løkke.

Bemærk, at det første element, der blev tilføjet til køen, er det, der fjernes! For eksempel, i ovenstående eksempel blev elementet med dataene "One" fjernet først.

FIFO-princippet illustreres nedenfor:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);         
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Vi kan gå videre til metoderne, der returnerer det første og sidste element:

element(): returnerer, men fjerner ikke, elementet fra begyndelsen af køen, kaster en undtagelse hvis køen er tom;
peek(): returnerer, men fjerner ikke, elementet fra begyndelsen af køen, returnerer null hvis køen er tom.

Brug af peek()-metoden er en mere pålidelig og sikker tilgang, da det hjælper med at undgå mulige undtagelser.

Lad os se et eksempel på brug:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        System.out.println("Queue: " + queue);
        System.out.println("The first element in the queue: " + queue.peek());
        System.out.println("Queue after the `peek()` method: " + queue);
    }
}

Du kan kombinere denne metode med andre kø-metoder.

Hvis du har en kø med fem elementer og har behov for at fjerne alle elementer op til og med det fjerde, lad os se implementeringen af en sådan operation:

Main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (!queue.peek().equals("Four")) {
            queue.poll();
        }
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Du brugte en løkke med en betingelse baseret på peek()-metoden.

Du kan betydeligt optimere denne løkke ved at bruge contains()-metoden. Denne metode returnerer true, hvis det angivne element er til stede i køen, og false, hvis det ikke er.

Lad os forbedre ovenstående kode:

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (queue.contains("Four")) {
            queue.poll();
        }
        System.out.println("Queue after removal operation: " + queue);
    }
}

Her sætter vi en enkelt betingelse for while -løkken. Vi har med succes fjernet alle elementer op til og med elementet "Four".

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 1

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Stryg for at vise menuen

På denne måde kan du implementere forskellige programmer, hvor kølogikken er gennemtænkt. For eksempel implementering af et board med planer og opgaver.

Men først skal vi se på de grundlæggende metoder til at arbejde med en Queue.

Queue er et interface, som LinkedList-klassen arver fra, hvilket du allerede kender, så vi vil bruge denne implementering.

Eksempel:

Example.java


              1234
            
// `LinkedList` as implementation of the `List` interface:
List<T> list = new LinkedList<>(); 
// `LinkedList` as implementation of the `Queue` interface:
Queue<T> queue = new LinkedList<>();

På denne måde kan du gøre vores applikation meget fleksibel ved at bruge forskellige implementeringer af den samme grænseflade.

Men lad os vende tilbage til metoderne til at arbejde med Queue.

Metoder

Nogle vigtige metoder i Queue-grænsefladen er:

add(element): tilføjer et element til køen, kaster en undtagelse hvis operationen ikke er mulig;
offer(element): tilføjer et element til køen, returnerer true hvis det lykkes eller false ellers.

Lad os se på et eksempel:

Main.java


              1234567891011121314
            
package com.example;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(2);
        queue.add("One");
        queue.add("Two");
        queue.add("Three");
        System.out.println("Queue: " + queue);
    }
}

Som du kan se, når du bruger add()-metoden og forsøger at tilføje et element, der ikke passer ind i køen, kaster programmet en fejl, hvilket uventet afslutter eksekveringen.

Lad os prøve den samme operation, men med en mere sikker metode — offer():

Main.java


              1234567891011121314
            
package com.example;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(2);
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        System.out.println("Queue: " + queue);
    }
}

Som du kan se, blev elementet ikke tilføjet til køen, men der blev heller ikke kastet en undtagelse. Derfor kan vi betragte det som om, vi håndterede fejlen elegant.

Du kan håndtere undtagelser på andre måder ved at bruge en struktur som try-catch, men det vil vi diskutere senere.

Fjernelsesmetoder

remove(): fjerner og returnerer elementet fra begyndelsen af køen, kaster en undtagelse hvis køen er tom;
poll(): fjerner og returnerer elementet fra begyndelsen af køen, returnerer null hvis køen er tom.

Her kan du også observere forskellen mellem disse to metoder. Metoden poll() bruges oftere end metoden remove(), fordi den er mere sikker og ikke kaster undtagelser.

Lad os se på et eksempel:

Main.java


              123456789101112131415
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        System.out.println("Queue: " + queue);
        queue.remove();
        queue.remove();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Som du kan se, kaster programmet en NoSuchElementException, fordi vi forsøger at fjerne et element fra en tom kø.

For at undgå en sådan undtagelse er det bedre at bruge poll()-metoden:

Main.java


              123456789101112131415
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        System.out.println("Queue: " + queue);
        queue.poll();
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Nu har vi fjernet et element fra køen på en sikker måde, og der blev ikke kastet nogen undtagelse, da vi forsøgte at fjerne et element fra en tom liste.

At poll() returnerer null kan for eksempel bruges i et while()-loop.

Lad os se på et eksempel:

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (queue.poll() != null) {
            queue.poll();
        }
        System.out.println("Queue after removal operation: " + queue);
    }
}

På denne måde kan alle elementer fjernes fra køen ved hjælp af en løkke.

Bemærk, at det første element, der blev tilføjet til køen, er det, der fjernes! For eksempel, i ovenstående eksempel blev elementet med dataene "One" fjernet først.

FIFO-princippet illustreres nedenfor:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);         
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Vi kan gå videre til metoderne, der returnerer det første og sidste element:

element(): returnerer, men fjerner ikke, elementet fra begyndelsen af køen, kaster en undtagelse hvis køen er tom;
peek(): returnerer, men fjerner ikke, elementet fra begyndelsen af køen, returnerer null hvis køen er tom.

Brug af peek()-metoden er en mere pålidelig og sikker tilgang, da det hjælper med at undgå mulige undtagelser.

Lad os se et eksempel på brug:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        System.out.println("Queue: " + queue);
        System.out.println("The first element in the queue: " + queue.peek());
        System.out.println("Queue after the `peek()` method: " + queue);
    }
}

Du kan kombinere denne metode med andre kø-metoder.

Hvis du har en kø med fem elementer og har behov for at fjerne alle elementer op til og med det fjerde, lad os se implementeringen af en sådan operation:

Main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (!queue.peek().equals("Four")) {
            queue.poll();
        }
        queue.poll();
        System.out.println("Queue after removal operation: " + queue);
    }
}

Du brugte en løkke med en betingelse baseret på peek()-metoden.

Du kan betydeligt optimere denne løkke ved at bruge contains()-metoden. Denne metode returnerer true, hvis det angivne element er til stede i køen, og false, hvis det ikke er.

Lad os forbedre ovenstående kode:

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("One");
        queue.offer("Two");
        queue.offer("Three");
        queue.offer("Four");
        queue.offer("Five");
        System.out.println("Queue: " + queue);
        while (queue.contains("Four")) {
            queue.poll();
        }
        System.out.println("Queue after removal operation: " + queue);
    }
}

Her sætter vi en enkelt betingelse for while -løkken. Vi har med succes fjernet alle elementer op til og med elementet "Four".

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 1

Queue Datastruktur i Java

Metoder

Fjernelsesmetoder

1. Hvad er en `Queue` i Java?

2. Hvilket interface repræsenterer en Queue i Java Collections Framework?

3. Hvad er formålet med `offer()`-metoden i `Queue`-interfacet?

4. Hvad gør `poll()`-metoden i `Queue`-interfacet?

5. Hvilken klasse i Javas `java.util.concurrent`-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af `add()`-metoden?

Queue Datastruktur i Java

Metoder

Fjernelsesmetoder

1. Hvad er en `Queue` i Java?

2. Hvilket interface repræsenterer en Queue i Java Collections Framework?

3. Hvad er formålet med `offer()`-metoden i `Queue`-interfacet?

4. Hvad gør `poll()`-metoden i `Queue`-interfacet?

5. Hvilken klasse i Javas `java.util.concurrent`-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af `add()`-metoden?

Queue Datastruktur i Java

Metoder

Fjernelsesmetoder

1. Hvad er en Queue i Java?

2. Hvilket interface repræsenterer en Queue i Java Collections Framework?

3. Hvad er formålet med offer()-metoden i Queue-interfacet?

4. Hvad gør poll()-metoden i Queue-interfacet?

5. Hvilken klasse i Javas java.util.concurrent-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af add()-metoden?

Queue Datastruktur i Java

Metoder

Fjernelsesmetoder

1. Hvad er en Queue i Java?

2. Hvilket interface repræsenterer en Queue i Java Collections Framework?

3. Hvad er formålet med offer()-metoden i Queue-interfacet?

4. Hvad gør poll()-metoden i Queue-interfacet?

5. Hvilken klasse i Javas java.util.concurrent-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af add()-metoden?

1. Hvad er en `Queue` i Java?

3. Hvad er formålet med `offer()`-metoden i `Queue`-interfacet?

4. Hvad gør `poll()`-metoden i `Queue`-interfacet?

5. Hvilken klasse i Javas `java.util.concurrent`-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af `add()`-metoden?

1. Hvad er en `Queue` i Java?

3. Hvad er formålet med `offer()`-metoden i `Queue`-interfacet?

4. Hvad gør `poll()`-metoden i `Queue`-interfacet?

5. Hvilken klasse i Javas `java.util.concurrent`-pakke repræsenterer en begrænset blokerende kø?

6. Hvad sker der, hvis du forsøger at tilføje et element til en fuld kø ved hjælp af `add()`-metoden?