Método BlockingQueue remove() en Java con ejemplos

El método remove(Object obj) de BlockingQueue elimina solo una instancia del Objeto dado, pasado como parámetro, de esta BlockingQueue si está presente. Elimina un elemento e tal que obj.equals(e) y si esta cola contiene una o más instancias del elemento e. Este método devuelve verdadero si esta cola contenía el elemento que ahora se elimina de BlockingQueue.

Sintaxis:

public boolean remove(Object o)

Parámetro: este método acepta un parámetro obligatorio obj , que es el elemento que se eliminará de BlockingQueue.

Valor devuelto: este método devuelve verdadero si esta cola contenía el elemento que ahora se elimina de BlockingQueue. Si BlockingQueue no contenía el elemento obj , este método devuelve false .

Nota : El método remove() de BlockingQueue se ha heredado de la clase Queue en Java.

Los siguientes programas ilustran el método remove(Object obj) de la clase BlockingQueue:

Programa 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);
    }
}
Producción:

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]

Programa 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();
        }
    }
}
Producción:

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]

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

Publicación traducida automáticamente

Artículo escrito por gopaldave y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *