Java - The Collection Algorithms

Il framework delle raccolte definisce diversi algoritmi che possono essere applicati a raccolte e mappe.

Questi algoritmi sono definiti come metodi statici all'interno della classe Collections. Molti dei metodi possono generare un fileClassCastException, che si verifica quando si tenta di confrontare tipi incompatibili o un file UnsupportedOperationException, che si verifica quando si tenta di modificare una raccolta non modificabile.

I metodi definiti nell'algoritmo del framework di raccolta sono riassunti nella seguente tabella:

Sr.No. Metodo e descrizione
1

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

Cerca il valore nell'elenco ordinato in base a c. Restituisce la posizione del valore nell'elenco o -1 se il valore non viene trovato.
2

static int binarySearch(List list, Object value)

Cerca il valore nell'elenco. L'elenco deve essere ordinato. Restituisce la posizione del valore nell'elenco o -1 se il valore non viene trovato.
3

static void copy(List list1, List list2)

Copia gli elementi di list2 in list1.
4

static Enumeration enumeration(Collection c)

Restituisce un'enumerazione c.
5

static void fill(List list, Object obj)

Assegna obj a ogni elemento della lista.
6

static int indexOfSubList(List list, List subList)

Cerca nell'elenco la prima occorrenza di subList. Restituisce l'indice della prima corrispondenza o .1 se non viene trovata alcuna corrispondenza.
7

static int lastIndexOfSubList(List list, List subList)

Cerca nella lista l'ultima occorrenza di subList. Restituisce l'indice dell'ultima corrispondenza o .1 se non viene trovata alcuna corrispondenza.
8

static ArrayList list(Enumeration enum)

Restituisce un ArrayList che contiene gli elementi di enum.
9

static Object max(Collection c, Comparator comp)

Restituisce l'elemento massimo in c come determinato da comp.
10

static Object max(Collection c)

Restituisce l'elemento massimo in ccome determinato dall'ordinamento naturale. La raccolta non deve essere ordinata.
11

static Object min(Collection c, Comparator comp)

Restituisce l'elemento minimo in ccome determinato da comp. La raccolta non deve essere ordinata.
12

static Object min(Collection c)

Restituisce l'elemento minimo in c come determinato dall'ordinamento naturale.
13

static List nCopies(int num, Object obj)

Restituisce num copie di obj contenute in un elenco immutabile. num deve essere maggiore o uguale a zero.
14

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

Sostituisce tutte le occorrenze del vecchio con il nuovo nell'elenco. Restituisce vero se si è verificata almeno una sostituzione. Restituisce falso, altrimenti.
15

static void reverse(List list)

Inverte la sequenza nell'elenco.
16

static Comparator reverseOrder( )

Restituisce un comparatore inverso.
17

static void rotate(List list, int n)

Ruota l'elenco di nposti a destra. Per ruotare a sinistra, utilizza un valore negativo pern.
18

static void shuffle(List list, Random r)

Mescola (cioè randomizza) gli elementi nell'elenco utilizzando r come fonte di numeri casuali.
19

static void shuffle(List list)

Mescola (cioè randomizza) gli elementi nell'elenco.
20

static Set singleton(Object obj)

Restituisce obj come un insieme immutabile. Questo è un modo semplice per convertire un singolo oggetto in un set.
21

static List singletonList(Object obj)

Restituisce obj come un elenco immutabile. Questo è un modo semplice per convertire un singolo oggetto in un elenco.
22

static Map singletonMap(Object k, Object v)

Restituisce la coppia chiave / valore k / v come mappa immutabile. Questo è un modo semplice per convertire una singola coppia chiave / valore in una mappa.
23

static void sort(List list, Comparator comp)

Ordina gli elementi della lista come determinato da comp.
24

static void sort(List list)

Ordina gli elementi dell'elenco in base al loro ordinamento naturale.
25

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

Scambia gli elementi nell'elenco in base agli indici specificati da idx1 e idx2.
26

static Collection synchronizedCollection(Collection c)

Restituisce una raccolta thread-safe supportata da c.
27

static List synchronizedList(List list)

Restituisce un elenco thread-safe supportato da elenco.
28

static Map synchronizedMap(Map m)

Restituisce una mappa thread-safe supportata da m.
29

static Set synchronizedSet(Set s)

Restituisce un set thread-safe supportato da s.
30

static SortedMap synchronizedSortedMap(SortedMap sm)

Restituisce un set ordinato thread-safe supportato da sm.
31

static SortedSet synchronizedSortedSet(SortedSet ss)

Restituisce un set thread-safe supportato da ss.
32

static Collection unmodifiableCollection(Collection c)

Restituisce una raccolta non modificabile supportata da c.
33

static List unmodifiableList(List list)

Restituisce un elenco non modificabile supportato dall'elenco.
34

static Map unmodifiableMap(Map m)

Restituisce una mappa non modificabile supportata da m.
35

static Set unmodifiableSet(Set s)

Restituisce un insieme non modificabile supportato da s.
36

static SortedMap unmodifiableSortedMap(SortedMap sm)

Restituisce una mappa ordinata non modificabile supportata da sm.
37

static SortedSet unmodifiableSortedSet(SortedSet ss)

Restituisce un insieme ordinato non modificabile supportato da ss.

Esempio

Di seguito è riportato un esempio, che mostra vari algoritmi.

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));
   }
}

Questo produrrà il seguente risultato:

Produzione

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