1. Lista metodelor

Vă amintiți că creatorii Java au scris o întreagă clasă de ajutor numită Arrayspentru confortul nostru atunci când lucrați cu matrice?

Au făcut același lucru pentru colecții. Java are o java.util.Collectionsclasă care are o mulțime de metode care sunt utile pentru lucrul cu colecții. Iată doar cele mai interesante:

Metode Descriere 
addAll(colls, e1, e2, e3, ...)
 Adaugă elementele e1, e2, e3, ... la collscolecție 
fill(list, obj)
 Înlocuiește toate elementele din lista trecută cuobj 
nCopies(n, obj)
 Returnează o listă de ncopii ale objobiectului 
replaceAll(list, oldVal, newVal)
 Înlocuiește toate instanțele de oldValcu newValdin listlistă 
copy(dest, src)
 Copiază toate elementele din srclistă în destlistă 
reverse(list)
 Inversează lista. 
sort(list)
 Sortează lista în ordine crescătoare 
rotate(list, n)
 Mută ​​ciclic elementele listei listpe nelemente 
shuffle(list)
 Amestecă aleatoriu elementele din listă 
min(colls)
 Găsește elementul minim din collscolecție 
max(colls)
 Găsește elementul maxim din collscolecție 
frequency(colls, obj)
 Determină de câte ori objapare elementul în collscolecție 
binarySearch(list, key)
 Caută keyîntr-o listă sortată și returnează indexul corespunzător. 
disjoint(colls1, colls2)
 Returnează truedacă colecțiile nu au elemente în comun
Important:

Multe dintre aceste metode nu folosesc clasele ArrayList, HashSetși HashMapper se, ci cu interfețele corespunzătoare: Collection<T>, List<T>, Map<K, V>.

Aceasta nu este o problemă: dacă o metodă acceptă un List<T>, puteți oricând să îi treceți un ArrayList<Integer>, dar operatorul de atribuire nu funcționează în direcția opusă.

Java webinar

2. Crearea și modificarea colecțiilor

Collections.addAll(Collection<T> colls, T e1, T e2, T e3, ...)metodă

Metoda addAll()adaugă elementele e1, e2, e3, ... la collscolecție Orice număr de elemente poate fi trecut.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

for (int i: list)
   System.out.println(i);
 
1
2
3
4
5

Collections.fill(List<T> list, T obj)metodă

Metoda fill()înlocuiește toate elementele colecției listcu objelementul.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.fill(list, 10);

for (int i: list)
   System.out.println(i);
 
10
10
10

Collections.nCopies(int n, T obj)metodă

Metoda nCopies()returnează o listă de ncopii ale objelementului. Rețineți că lista returnată este imuabilă, ceea ce înseamnă că nu o puteți modifica! Îl puteți folosi doar pentru a citi valori:

Cod Descriere 
List<String> immutableList = Collections.nCopies(5, "Hello");

ArrayList<String> list = new ArrayList<String>(immutableList);

for(String s: list)
   System.out.println(s);
 Creați o listă imuabilă de 5 Helloșiruri de caractere
Creați o listă mutabilă listși completați-l cu valorile din immutableListlistă.

Ieșire din consolă:
Hello
Hello
Hello
Hello
Hello

Collections.replaceAll (List<T> list, T oldValue, T newValue)metodă

Metoda replaceAll()înlocuiește toate elementele din listcolecție egale oldValuecu newValue.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.replaceAll(list, 2, 20);

for (int i: list)
   System.out.println(i);
 
1
20
3

Collections.copy (List<T> dest, List<T> src)metodă

Metoda copy()copiază toate elementele colecției srcîn destcolecție.

Dacă destcolecția începe mai mult decât srccolecția, atunci elementele rămase ale destcolecției vor rămâne intacte.

Important:
Colecția desttrebuie să fie cel puțin la fel de lungă ca și srccolecția (în caz contrar, IndexOutOfBoundsExceptionva fi aruncat).
Cod Ieșire de consolă 
ArrayList<Integer> srcList = new ArrayList<Integer>();
Collections.addAll(srcList, 99, 98, 97);

ArrayList<Integer> destList = new ArrayList<Integer>();
Collections.addAll(destList, 1, 2, 3, 4, 5, 6, 7);

Collections.copy(destList, srcList);

for (int i: destList)
   System.out.println(i);
 
99
98
97
4
5
6
7

3. Ordinea elementelor

Collections.reverse(List<T> list)metodă

Metoda reverse()inversează ordinea elementelor listei trecute.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.reverse(list);

for (int i: list)
   System.out.println(i);
 
5
4
3
2
1

Collections.sort(List<T> list)metodă

Metoda sort()sortează lista trecută în ordine crescătoare.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

Collections.sort(list);

for (int i: list)
   System.out.println(i);
 
2
4
11
15
23

Collections.rotate(List<T> list, int distance)metodă

Metoda rotate()mută în mod ciclic elementele listei trecute cu distancepoziții înainte.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Collections.rotate(list, 3); // Shift by 3 positions

for (int i: list)
   System.out.println(i);
 
7
8
9
1
2
3
4
5
6

Collections.shuffle(List<T> list)metodă

Metoda shuffle()amestecă aleatoriu toate elementele listei trecute. Rezultatul este diferit de fiecare dată.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.shuffle(list); // Shuffle the elements

for (int i: list)
   System.out.println(i);
 
5
2
4
3
1

4. Găsirea elementelor în colecții

Collections.min(Collection<T> colls)metodă

Metoda min()returnează elementul minim din colecție.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int min = Collections.min(list);

System.out.println(min);
 
2

Collections.max(Collection<T> colls)metodă

Metoda max()returnează elementul maxim din colecție.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int max = Collections.max(list);

System.out.println(max);
 
23

Collections.frequency(Collection<T> colls, T obj)metodă

Metoda frequency()numără de câte ori objapare elementul în collscolecție

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15, 4, 2, 4);

int count = Collections.frequency(list, 4);

System.out.println(count);
 
3

Collections.binarySearch(Collection<T> colls, T obj)metodă

Metoda binarySearch()caută elementul objdin collscolecție. Returnează indexul elementului găsit. Returnează un număr negativ dacă elementul nu este găsit.

Important:
Înainte de a apela binarySearch()metoda, colecția trebuie sortată (utilizați Collections.sort()).
Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 5, 15, 4, 2, 4);

Collections.sort(list);  // 2, 2, 4, 4, 5, 11, 15, 23

int index = Collections.binarySearch(list, 5);    // 4
System.out.println(index);

int index2 = Collections.binarySearch(list, 15);  // 6
System.out.println(index2);

int index3 = Collections.binarySearch(list, 16); // The element doesn't exist
System.out.println(index3);
 
4
6
-8

Collections.disjoint(Collection<T> coll1, Collection<T> coll2)metodă

Metoda disjoint()revine truedacă colecțiile trecute nu au niciun element în comun.

Cod Ieșire de consolă 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

ArrayList<Integer> list2 = new ArrayList<Integer>();
Collections.addAll(list2, 99, 98, 97);

boolean isDifferent = Collections.disjoint(list, list2);
System.out.println(isDifferent);
 
true