Java - Les algorithmes de collecte

Le cadre des collections définit plusieurs algorithmes qui peuvent être appliqués aux collections et aux cartes.

Ces algorithmes sont définis comme des méthodes statiques dans la classe Collections. Plusieurs des méthodes peuvent lancer unClassCastException, qui se produit lorsqu'une tentative est faite pour comparer des types incompatibles, ou un UnsupportedOperationException, qui se produit lorsqu'une tentative est faite pour modifier une collection non modifiable.

Les méthodes définies dans l'algorithme du framework de collecte sont résumées dans le tableau suivant -

N ° Sr. Méthode et description
1

static int binarySearch(List list, Object value, Comparator c)

Recherche la valeur dans la liste classée selon c. Renvoie la position de la valeur dans la liste, ou -1 si la valeur n'est pas trouvée.
2

static int binarySearch(List list, Object value)

Recherche la valeur dans la liste. La liste doit être triée. Renvoie la position de la valeur dans la liste, ou -1 si la valeur n'est pas trouvée.
3

static void copy(List list1, List list2)

Copie les éléments de list2 dans list1.
4

static Enumeration enumeration(Collection c)

Renvoie une énumération sur c.
5

static void fill(List list, Object obj)

Assigne obj à chaque élément de la liste.
6

static int indexOfSubList(List list, List subList)

Recherche dans la liste la première occurrence de subList. Renvoie l'index de la première correspondance, ou .1 si aucune correspondance n'est trouvée.
sept

static int lastIndexOfSubList(List list, List subList)

Recherche dans la liste la dernière occurrence de subList. Renvoie l'index de la dernière correspondance, ou .1 si aucune correspondance n'est trouvée.
8

static ArrayList list(Enumeration enum)

Renvoie un ArrayList qui contient les éléments d'énumération.
9

static Object max(Collection c, Comparator comp)

Renvoie l'élément maximum dans c comme déterminé par comp.
dix

static Object max(Collection c)

Renvoie l'élément maximum dans ctel que déterminé par l'ordre naturel. La collection n'a pas besoin d'être triée.
11

static Object min(Collection c, Comparator comp)

Renvoie l'élément minimum dans ccomme déterminé par comp. La collection n'a pas besoin d'être triée.
12

static Object min(Collection c)

Renvoie l'élément minimum dans c tel que déterminé par l'ordre naturel.
13

static List nCopies(int num, Object obj)

Renvoie nombre de copies d'obj contenues dans une liste immuable. num doit être supérieur ou égal à zéro.
14

static boolean replaceAll(List list, Object old, Object new)

Remplace toutes les occurrences d'ancien par nouveau dans la liste. Renvoie vrai si au moins un remplacement a eu lieu. Renvoie false, sinon.
15

static void reverse(List list)

Inverse la séquence dans la liste.
16

static Comparator reverseOrder( )

Renvoie un comparateur inversé.
17

static void rotate(List list, int n)

Fait pivoter la liste de nendroits à droite. Pour faire pivoter vers la gauche, utilisez une valeur négative pourn.
18

static void shuffle(List list, Random r)

Mélange (c.-à-d. Randomise) les éléments de la liste en utilisant r comme source de nombres aléatoires.
19

static void shuffle(List list)

Mélange (c.-à-d. Randomise) les éléments de la liste.
20

static Set singleton(Object obj)

Renvoie obj sous la forme d'un ensemble immuable. C'est un moyen simple de convertir un seul objet en un ensemble.
21

static List singletonList(Object obj)

Renvoie obj sous la forme d'une liste immuable. C'est un moyen facile de convertir un seul objet en une liste.
22

static Map singletonMap(Object k, Object v)

Renvoie la paire clé / valeur k / v sous la forme d'une carte immuable. C'est un moyen simple de convertir une seule paire clé / valeur en une carte.
23

static void sort(List list, Comparator comp)

Trie les éléments de la liste comme déterminé par comp.
24

static void sort(List list)

Trie les éléments de la liste selon leur ordre naturel.
25

static void swap(List list, int idx1, int idx2)

Échange les éléments de la liste aux indices spécifiés par idx1 et idx2.
26

static Collection synchronizedCollection(Collection c)

Renvoie une collection thread-safe soutenue par c.
27

static List synchronizedList(List list)

Renvoie une liste thread-safe soutenue par list.
28

static Map synchronizedMap(Map m)

Renvoie une carte thread-safe soutenue par m.
29

static Set synchronizedSet(Set s)

Renvoie un ensemble thread-safe soutenu par s.
30

static SortedMap synchronizedSortedMap(SortedMap sm)

Renvoie un ensemble trié thread-safe soutenu par sm.
31

static SortedSet synchronizedSortedSet(SortedSet ss)

Renvoie un ensemble thread-safe soutenu par ss.
32

static Collection unmodifiableCollection(Collection c)

Renvoie une collection non modifiable soutenue par c.
33

static List unmodifiableList(List list)

Renvoie une liste non modifiable soutenue par la liste.
34

static Map unmodifiableMap(Map m)

Renvoie une carte non modifiable soutenue par m.
35

static Set unmodifiableSet(Set s)

Renvoie un ensemble non modifiable soutenu par s.
36

static SortedMap unmodifiableSortedMap(SortedMap sm)

Renvoie une carte triée non modifiable soutenue par sm.
37

static SortedSet unmodifiableSortedSet(SortedSet ss)

Renvoie un ensemble trié non modifiable soutenu par ss.

Exemple

Voici un exemple illustrant divers algorithmes.

import java.util.*;
public class AlgorithmsDemo {

   public static void main(String args[]) {
      
      // Create and initialize linked list
      LinkedList ll = new LinkedList();
      ll.add(new Integer(-8));
      ll.add(new Integer(20));
      ll.add(new Integer(-20));
      ll.add(new Integer(8));
      
      // Create a reverse order comparator
      Comparator r = Collections.reverseOrder();
      
      // Sort list by using the comparator
      Collections.sort(ll, r);
      
      // Get iterator
      Iterator li = ll.iterator();
      System.out.print("List sorted in reverse: ");
      
      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }
      System.out.println();
      Collections.shuffle(ll);
      
      // display randomized list
      li = ll.iterator();
      System.out.print("List shuffled: ");
      
      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }

      System.out.println();
      System.out.println("Minimum: " + Collections.min(ll));
      System.out.println("Maximum: " + Collections.max(ll));
   }
}

Cela produira le résultat suivant -

Production

List sorted in reverse: 20 8 -8 -20
List shuffled: 20 -20 8 -8
Minimum: -20
Maximum: 20