Implement a small program using PriorityQueue to simulate a job scheduler.

Here’s an implementation of a small program using a PriorityQueue to simulate a job scheduler. In this example, jobs have priorities, and the job scheduler processes the highest-priority jobs first (lower numbers represent higher priorities).

Java Program: Job Scheduler using `PriorityQueue`

import java.util.PriorityQueue;
import java.util.Comparator;

// Class representing a Job with a priority and a name
class Job {
    private String name;
    private int priority;

    public Job(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public String getName() {
        return name;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Job[name=" + name + ", priority=" + priority + "]";
    }
}

public class JobScheduler {
    public static void main(String[] args) {
        // Create a PriorityQueue with a custom comparator to order jobs by priority
        PriorityQueue<Job> jobQueue = new PriorityQueue<>(new Comparator<Job>() {
            @Override
            public int compare(Job j1, Job j2) {
                return Integer.compare(j1.getPriority(), j2.getPriority());
            }
        });

        // Add jobs to the PriorityQueue (lower priority number means higher importance)
        jobQueue.add(new Job("Database backup", 3));
        jobQueue.add(new Job("Send report to manager", 1));
        jobQueue.add(new Job("System update", 5));
        jobQueue.add(new Job("Email notifications", 2));

        // Simulate processing the jobs
        System.out.println("Processing jobs in priority order:");
        while (!jobQueue.isEmpty()) {
            Job job = jobQueue.poll(); // Retrieves and removes the highest-priority job
            System.out.println("Processing: " + job);
        }
    }
}

Explanation:

Job Class: Represents a job with a name and priority. The lower the priority value, the higher its importance (e.g., a priority of 1 is higher than a priority of 5).
PriorityQueue: The job queue is a PriorityQueue that orders jobs based on their priority. We define a custom comparator to ensure that jobs with lower priority numbers are processed first.
Main Logic:
- Jobs are added to the queue with different priority levels.
- The jobs are processed in priority order using the poll() method, which retrieves and removes the highest-priority job (smallest number).

Output:

Processing jobs in priority order:
Processing: Job[name=Send report to manager, priority=1]
Processing: Job[name=Email notifications, priority=2]
Processing: Job[name=Database backup, priority=3]
Processing: Job[name=System update, priority=5]

Key Points:

PriorityQueue ensures that jobs are processed based on priority.
Comparator is used to define the order in which jobs are scheduled (higher priority jobs are processed first).
poll() retrieves and removes the highest-priority job from the queue.

This simple job scheduler demonstrates how a PriorityQueue can be used to handle tasks based on their priority in a real-world scenario like system job scheduling.