Kolejki, stosy i Deque w praktyce

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * Kolejki, stosy i Deque w praktyce — skryptyJAVA.pl
 * Zapisz jako: KolejkiIStosy.java
 */
public class KolejkiIStosy {

    /** Pozycja cennika; cena w groszach, żeby nie liczyć pieniędzy na double. */
    public record Pozycja(String nazwa, int cenaGrosze) {
        @Override
        public String toString() {
            return String.format("%s %d,%02d zł", nazwa, cenaGrosze / 100, cenaGrosze % 100);
        }
    }

    /** Dokłada stan na wierzchołek historii; najstarszy wypada z przeciwnego końca. */
    public static void zapamietaj(Deque<String> historia, String stan, int limit) {
        historia.push(stan);
        while (historia.size() > limit) {
            historia.removeLast();
        }
    }

    /** Zdejmuje ostatni stan; przy pustej historii zwraca null zamiast rzucać wyjątkiem. */
    public static String cofnij(Deque<String> historia) {
        return historia.poll();
    }

    /** Przetwarza zadania w kolejności zgłoszenia i zwraca liczbę obsłużonych. */
    public static int przetworzZadania(Queue<String> zadania) {
        int obsluzone = 0;
        // Warunek „aż do null” niesie założenie: kolejka nie wpuszcza null-i. LinkedList je łamie.
        for (String zadanie = zadania.poll(); zadanie != null; zadanie = zadania.poll()) {
            System.out.println("    wykonuję: " + zadanie + " (zostało " + zadania.size() + ")");
            obsluzone++;
        }
        return obsluzone;
    }

    /** Kolejka priorytetowa ustawiająca na czele najdroższą pozycję. */
    public static PriorityQueue<Pozycja> wedlugCenyMalejaco(List<Pozycja> pozycje) {
        Comparator<Pozycja> odNajdrozszych = Comparator.comparingInt(Pozycja::cenaGrosze).reversed();
        PriorityQueue<Pozycja> kolejka = new PriorityQueue<>(odNajdrozszych);
        kolejka.addAll(pozycje);
        return kolejka;
    }

    /** Zdejmuje kolejne elementy kolejki — priorytet respektuje wyłącznie poll(). */
    public static List<Pozycja> zdejmij(Queue<Pozycja> kolejka, int ile) {
        List<Pozycja> wynik = new ArrayList<>();
        for (int i = 0; i < ile && !kolejka.isEmpty(); i++) {
            wynik.add(kolejka.poll());
        }
        return wynik;
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    private static void demoStosu() {
        System.out.println("== Stos: historia cofania, limit 3 kroki ==");
        Deque<String> historia = new ArrayDeque<>();
        List.of("pusty dokument", "tytuł", "akapit", "tabela")
                .forEach(stan -> zapamietaj(historia, stan, 3));
        Stack<String> staryStos = new Stack<>();
        historia.descendingIterator().forEachRemaining(staryStos::push);
        System.out.println("ArrayDeque wypisuje od wierzchołka: " + historia);
        System.out.println("Stack ten sam stos, ale od dna:     " + staryStos);
        System.out.println("Cofam " + cofnij(historia) + ", na wierzchu zostaje " + historia.peek());
    }

    private static void demoKolejki() {
        System.out.println(System.lineSeparator() + "== Kolejka zadań i dwie rodziny metod ==");
        Queue<String> zadania = new ArrayDeque<>(List.of("wyślij fakturę", "przelicz raport"));
        zadania.offer("wyczyść cache");
        System.out.println("Na czele: " + zadania.peek() + ", czeka zadań: " + zadania.size());
        System.out.println("Obsłużono zadań: " + przetworzZadania(zadania));
        System.out.println("Pusta: poll() = " + zadania.poll() + ", peek() = " + zadania.peek());
        try {
            zadania.remove();
        } catch (NoSuchElementException e) {
            System.out.println("Pusta: remove() rzuca " + e.getClass().getSimpleName());
        }
        // Na ArrayDeque add i offer robią to samo — różnicę widać dopiero na kolejce z limitem.
        Queue<String> ciasna = new ArrayBlockingQueue<>(1);
        ciasna.offer("pierwsze");
        System.out.println("Pełna: offer() = " + ciasna.offer("drugie"));
        try {
            ciasna.add("drugie");
        } catch (IllegalStateException e) {
            System.out.println("Pełna: add() rzuca " + e.getClass().getSimpleName());
        }
        try {
            new ArrayDeque<String>().offer(null);
        } catch (NullPointerException e) {
            System.out.println("ArrayDeque.offer(null) rzuca " + e.getClass().getSimpleName());
        }
        // LinkedList null przyjmie — i właśnie tym psuje pętlę „pobieraj, aż wyjdzie null”.
        Deque<String> zNullem = new LinkedList<>(List.of("wyślij fakturę"));
        zNullem.offerFirst(null);
        System.out.println("LinkedList z null-em: obsłużono " + przetworzZadania(zNullem)
                + " zadań, a w kolejce nadal czeka: " + zNullem.peek());
    }

    private static void demoPriorytetow() {
        System.out.println(System.lineSeparator() + "== PriorityQueue: najdroższe pozycje ==");
        List<Pozycja> cennik = List.of(new Pozycja("Kawa", 8990), new Pozycja("Filtry", 1250),
                new Pozycja("Termometr", 12900), new Pozycja("Ekspres", 249900),
                new Pozycja("Waga", 32900), new Pozycja("Młynek", 45900));
        PriorityQueue<Pozycja> wgCeny = wedlugCenyMalejaco(cennik);
        System.out.println("Surowy toString: " + wgCeny);
        System.out.println("Kolejne poll():  " + zdejmij(wgCeny, cennik.size()));
        System.out.println("Trzy najdroższe: " + zdejmij(wedlugCenyMalejaco(cennik), 3));
    }

    public static void main(String[] args) {
        demoStosu();
        demoKolejki();
        demoPriorytetow();
    }
}