* `add(E e)` / `offer(E e)` (Invoeging): O(log n) - Dit komt omdat de prioriteitswachtrij zijn heap-eigenschap moet behouden, wat vereist dat het nieuwe element omhoog of omlaag in de heap wordt gezeefd.

* `remove()` / `poll()` (Verwijdering van het element met de hoogste prioriteit): O(log n) - Het verwijderen van het rootelement (hoogste prioriteit) vereist het vervangen ervan door het laatste element en het vervolgens door de heap zeven van het vervangende element om de heap-eigenschap te herstellen.

* `peek()` (Toegang tot het element met de hoogste prioriteit): O(1) - Gluren naar het element met de hoogste prioriteit (de root van de heap) is een directe toegang.

* `bevat(Object o)`: O(n) - Dit vereist het doorlopen van de elementen van de wachtrij om te controleren op gelijkheid. PriorityQueues in Java bieden geen efficiënte manier om te controleren op insluiting.

* `verwijder(Object o)`: O(n) - Net als bij `contains()` houdt dit in dat je door de elementen heen moet lopen om het opgegeven object te vinden en te verwijderen. Na het verwijderen van het object moet de heap-eigenschap behouden blijven, wat in het ergste geval O(n) tijd kan duren. (Het verwijderen van een willekeurig element is geen standaardwachtrijbewerking met prioriteit, en de prestaties weerspiegelen dit.)

* `grootte()`: O(1) - De grootte wordt bijgehouden als een lidvariabele, dus toegang ertoe is een constante tijdbewerking.

* `isEmpty()`: O(1) - Controleert eenvoudig of de maat 0 is.

* `clear()`: O(n) - Verwijdert alle elementen uit de wachtrij. Hoewel het verwijderen van individuele elementen O(log n) kan duren, duurt het wissen van de hele wachtrij O(n). In sommige implementaties kan dit feitelijk worden geïmplementeerd als O(1), door eenvoudigweg de interne array en grootte opnieuw in te stellen.

* `iterator()`: O(1) - Retourneert een iterator voor de prioriteitswachtrij. De iterator zelf is *niet* geordend, en het doorlopen van de elementen zal O(n) zijn.

Belangrijke overwegingen:

* `PriorityQueue` is geïmplementeerd als een binaire heap. De heap-datastructuur zorgt voor de logaritmische prestaties voor het invoegen en verwijderen van het element met de hoogste prioriteit.

* De vergelijker is cruciaal. De comparator (of de natuurlijke volgorde van de elementen als er geen comparator is voorzien) bepaalt de prioriteit van de elementen. De 'compare()'-methode van de comparator moet efficiënt zijn (typisch O(1)) zodat de algehele prioriteitswachtrijbewerkingen hun opgegeven complexiteit kunnen behouden.

* Het verwijderen van willekeurige elementen (`remove(Object o)`) is inefficiënt. Als u regelmatig willekeurige elementen uit een prioriteitswachtrij moet verwijderen, overweeg dan om een ​​andere datastructuur of een combinatie van datastructuren te gebruiken (bijvoorbeeld een `TreeSet` gecombineerd met een `HashMap` om de posities van elementen bij te houden). Standaard prioriteitswachtrijen zijn geoptimaliseerd voor efficiënte toegang tot het element met de hoogste prioriteit.

Samengevat:

De belangrijkste bewerkingen van `add()` en `remove()` (van het *hoogste* prioriteitselement) zijn O(log n), waardoor `PriorityQueue` een zeer efficiënte keuze is voor scenario's waarin u een gesorteerde verzameling moet onderhouden en herhaaldelijk het minimum (of maximum, afhankelijk van uw comparator) element moet openen of verwijderen.