Java Program Implement Queue Data Structure (FIFO)

Queue (คิว) คืออะไร?

Queue เป็นโครงสร้างข้อมูลแบบ Linear ที่ปฏิบัติตามหลัก FIFO (First In First Out) - ตัวแรกเข้า ตัวแรกออก

เหมือนคิวจริง: คนมาก่อน ได้รับบริการก่อน

Interface และ Implementation ใน Java

Interface/Class	คำอธิบาย	Thread-Safe
`Queue<E>`	Interface หลัก	-
`LinkedList<E>`	General-purpose, implements Queue, Deque	❌
`ArrayDeque<E>`	Array-based Deque, เร็วกว่า LinkedList สำหรับ Queue	❌
`PriorityQueue<E>`	Priority-based (ไม่ใช่ FIFO แบบตรงไปตรงมา)	❌
`ConcurrentLinkedQueue`	Thread-safe, Non-blocking	✅
`ArrayBlockingQueue`	Bounded, Blocking, Thread-safe	✅

เมธอดหลักของ Queue Interface

เมธอด	คำอธิบาย	Throws Exception	Returns Special Value
Insert	`add(e)`	`offer(e)`	คืน boolean
Remove	`remove()`	`poll()`	คืน null ถ้าว่าง
Examine	`element()`	`peek()`	คืน null ถ้าว่าง

ตัวอย่างที่ 1: ใช้ Built-in Queue (LinkedList)

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

public class Demo {
    public static void main(String[] args) {
        System.out.println("The required packages have been imported");
        
        Queue queue = new LinkedList<>();
        
        // Enqueue (เพิ่มท้าย)
        queue.offer(150);
        queue.offer(300);
        queue.offer(450);
        queue.offer(600);
        
        System.out.println("The queue is defined as: " + queue);
        // [150, 300, 450, 600]
        
        // Dequeue (ลบหน้า)
        int removed = queue.poll();
        System.out.println("Removed: " + removed); // 150
        
        System.out.println("After removing, queue: " + queue);
        // [300, 450, 600]
        
        // Peek (ดูหน้าโดยไม่ลบ)
        System.out.println("Front element: " + queue.peek()); // 300
    }
}

ผลลัพธ์

The required packages have been imported
The queue is defined as: [150, 300, 450, 600]
Removed: 150
After removing, queue: [300, 450, 600]
Front element: 300

ตัวอย่างที่ 2: Custom Array-based Queue Implementation

public class ArrayQueue {
    private int[] items;
    private int front = 0;
    private int rear = -1;
    private int size = 0;
    private int capacity;
    
    public ArrayQueue(int capacity) {
        this.capacity = capacity;
        this.items = new int[capacity];
    }
    
    // Enqueue - เพิ่มท้าย
    public void enqueue(int item) {
        if (isFull()) {
            throw new IllegalStateException("Queue is full");
        }
        rear = (rear + 1) % capacity; // Circular
        items[rear] = item;
        size++;
    }
    
    // Dequeue - ลบหน้า
    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        int item = items[front];
        items[front] = 0; // Optional: clear
        front = (front + 1) % capacity; // Circular
        size--;
        return item;
    }
    
    // Peek - ดูหน้า
    public int peek() {
        if (isEmpty()) throw new IllegalStateException("Queue is empty");
        return items[front];
    }
    
    public boolean isEmpty() { return size == 0; }
    public boolean isFull() { return size == capacity; }
    public int size() { return size; }
    
    public void display() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            return;
        }
        System.out.print("Queue: ");
        for (int i = 0; i < size; i++) {
            int index = (front + i) % capacity;
            System.out.print(items[index] + " ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        ArrayQueue q = new ArrayQueue(5);
        
        for (int i = 1; i <= 5; i++) {
            q.enqueue(i * 100);
        }
        q.display(); // Queue: 100 200 300 400 500
        
        q.enqueue(600); // Exception: Queue is full
        
        q.dequeue(); // Remove 100
        q.display(); // Queue: 200 300 400 500
    }
}

ผลลัพธ์

Queue: 100 200 300 400 500
Exception: Queue is full
Queue: 200 300 400 500

ArrayDeque: Queue ที่แนะนำสำหรับ General Purpose

import java.util.ArrayDeque;
import java.util.Queue;

Queue queue = new ArrayDeque<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);

int first = queue.poll(); // 1
int peek = queue.peek();  // 2

// ArrayDeque เร็วกว่า LinkedList เพราะ:
// - Memory contiguous (Cache friendly)
// - ไม่มี Node Object Overhead
// - Amortized O(1) ทุก Operation

BlockingQueue สำหรับ Producer-Consumer

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

// Producer Thread
new Thread(() -> {
    try {
        queue.put(item); // Block ถ้า Queue เต็ม
    } catch (InterruptedException e) { ... }
}).start();

// Consumer Thread
new Thread(() -> {
    try {
        Item item = queue.take(); // Block ถ้า Queue ว่าง
        process(item);
    } catch (InterruptedException e) { ... }
}).start();

สรุป

Queue = FIFO (First In First Out)
ใช้ offer() เพิ่ม, poll() ลบ, peek() ดู
General Purpose: ArrayDeque (เร็วกว่า LinkedList)
Thread-Safe: ConcurrentLinkedQueue (Non-blocking) หรือ ArrayBlockingQueue (Blocking)
Custom Implementation: Circular Array (O(1) ทุก Operation)