human
Comment puis-je faire en sorte qu'une ```PriorityQueue``` se trie selon ce que je veux trier ?
De plus, y a-t-il une différence entre les méthodes ```offer``` et ```add```
gpt
## Solution Java 8
Nous pouvons utiliser une ```expression lambda``` ou une ```référence de méthode``` introduite dans Java 8. Dans le cas où nous avons des valeurs de type String stockées dans la Priority Queue (avec une capacité de 5), nous pouvons fournir un comparateur en ligne (basé sur la longueur de la chaîne) :
Utilisation d'une expression lambda
```PriorityQueue pq=
                    new PriorityQueue(5,(a,b) -> a.length() - b.length());
```
Utilisation d'une référence de méthode
```PriorityQueue pq=
                new PriorityQueue(5, Comparator.comparing(String::length));
```
Ensuite, nous pouvons les utiliser comme suit :
```public static void main(String[] args) {
        PriorityQueue pq=
                new PriorityQueue(5, (a,b) -> a.length() - b.length());
       // ou pq = new PriorityQueue(5, Comparator.comparing(String::length));
        pq.add("Apple");
        pq.add("PineApple");
        pq.add("Custard Apple");
        while (pq.size() != 0)
        {
            System.out.println(pq.remove());
        }
    }
```
Cela affichera :
```Apple
PineApple
Custard Apple
```
Pour inverser l'ordre (pour le changer en une file de priorité maximale), il suffit de changer l'ordre dans le comparateur en ligne ou d'utiliser ```reversed``` comme suit :
```PriorityQueue pq = new PriorityQueue(5,
                             Comparator.comparing(String::length).reversed());
```
Nous pouvons également utiliser ```Collections.reverseOrder``` :
```PriorityQueue pqInt = new PriorityQueue(10, Collections.reverseOrder());
PriorityQueue pq = new PriorityQueue(5,
                Collections.reverseOrder(Comparator.comparing(String::length))
```
Nous pouvons donc voir que ```Collections.reverseOrder``` est surchargée pour prendre un comparateur qui peut être utile pour les objets personnalisés. La méthode ```reversed``` utilise en réalité ```Collections.reverseOrder``` :
```default Comparator reversed() {
    return Collections.reverseOrder(this);
}
```
offer() vs add()
Selon la documentation :

  > La méthode offer insère un élément si possible, sinon elle renvoie false. Cela diffère de la méthode Collection.add, qui peut échouer à ajouter un élément uniquement en lançant une exception non vérifiée. La méthode offer est conçue pour être utilisée lorsque l'échec est une occurrence normale, plutôt qu'exceptionnelle, par exemple dans les files d'attente de capacité fixe (ou "bornées").

Lors de l'utilisation d'une file d'attente à capacité limitée, offer() est généralement préférable à add(), qui peut échouer à insérer un élément uniquement en lançant une exception. Et PriorityQueue est une file d'attente de priorité non bornée basée sur un tas de priorité.