BlockingQueue remove() method in Java with examples

The remove(Object obj) method of BlockingQueue removes only one instance of the given Object, passed as parameter, from this BlockingQueue if it is present. It removes an element e such that obj.equals(e) and if this queue contains one or more instance of element e. This method returns true if this queue contained the element which is now removed from BlockingQueue.

Syntax:

public boolean remove(Object o)

Parameter: This method accepts a mandatory parameter obj which is the element to be removed from BlockingQueue.

Return Value: This method returns true if this queue contained the element which is now removed from BlockingQueue. If the BlockingQueue did not contain the element obj, then this method returns false.

Note: The remove() method of BlockingQueue has been inherited from the Queue class in Java.

Below programs illustrates remove(Object obj) method of BlockingQueue class:

Program 1:

// Java Program Demonstrate  remove(Object obj)
// method of BlockingQueue

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

public class GFG {

    public static void main(String[] args)
        throws InterruptedException
    {
        // define capacity of BlockingQueue
        int capacityOfQueue = 4;

        // create object of BlockingQueue
        BlockingQueue<String> BQ
            = new LinkedBlockingQueue<String>(capacityOfQueue);

        // Add element using put() method
        BQ.put("Karan");
        BQ.put("Suraj");
        BQ.put("Harsh");
        BQ.put("Rahul");

        // print elements of queue
        System.out.println("Items in Queue are " + BQ);

        // try to remove Karan from Queue using remove()
        boolean try1 = BQ.remove("Karan");
        // Print result of remove()
        System.out.println("String name Karan is removed :"
                           + try1);

        // try to remove Sunny from Queue using remove()
        boolean try2 = BQ.remove("Sunny");
        // Print result of remove()
        System.out.println("String name Sunny is removed :"
                           + try2);

        // try to remove Sunny from Queue using remove()
        boolean try3 = BQ.remove("Harsh");
        // Print result of remove()
        System.out.println("String name Harsh is removed :"
                           + try2);

        // print queue
        System.out.println("After Removing Some Elements:");
        System.out.println("Items in Queue are " + BQ);
    }
}

Output:

Items in Queue are [Karan, Suraj, Harsh, Rahul]
String name Karan is removed :true
String name Sunny is removed :false
String name Harsh is removed :false
After Removing Some Elements:
Items in Queue are [Suraj, Rahul]

Program 1:

// Java Program Demonstrate remove(object obj)
// method of BlockingQueue

import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class GFG {

    public void removeDemo() throws InterruptedException
    {
        // define capacity of BlockingQueue
        int capacityOfQueue = 5;

        // create object of BlockingQueue
        BlockingQueue<Employee> BQ
            = new LinkedBlockingQueue<Employee>(capacityOfQueue);

        // Add element to LinkedBlockingQueue
        Employee emp1 = new Employee("Ranjeet", "Tester", "29000", 27);
        Employee emp2 = new Employee("Sanjeet", "Manager", "98000", 34);
        Employee emp3 = new Employee("Karan", "Analyst", "44000", 30);

        // Add Employee Objects to BQ Using put(E e)
        BQ.put(emp1);
        BQ.put(emp2);
        BQ.put(emp3);

        // print details of BQ
        System.out.println("Before removing Elements");
        Iterator itr = BQ.iterator();
        while (itr.hasNext())
            System.out.println(itr.next());

        // remove employee2 name Sanjeet from BQ
        // Using remove(Object obj) method
        BQ.remove(emp2);

        // Also remove Ranjeet employee1 from BQ
        // Using remove(Object obj) method
        BQ.remove(emp1);

        // print details of BQ
        System.out.println("After removing Some Elements");
        itr = BQ.iterator();
        while (itr.hasNext())
            System.out.println(itr.next());
    }

    // create an Employee Object with name,
    // position, salary and age as attributes
    public class Employee {

        public String name;
        public String position;
        public String salary;
        public int Age;
        Employee(String name, String position,
                 String salary, int age)
        {
            this.name = name;
            this.position = position;
            this.salary = salary;
            this.Age = age;
        }

        @Override
        public String toString()
        {
            return "Employee [name=" + name + ", position="
                + position + ", salary=" + salary + ", Age=" + Age + "]";
        }
    }

    // Main Method
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        try {
            gfg.removeDemo();
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Output:

Before removing Elements
Employee [name=Ranjeet, position=Tester, salary=29000, Age=27]
Employee [name=Sanjeet, position=Manager, salary=98000, Age=34]
Employee [name=Karan, position=Analyst, salary=44000, Age=30]
After removing Some Elements
Employee [name=Karan, position=Analyst, salary=44000, Age=30]

Reference: https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html#remove(java.lang.Object)