1. Listahan ng mga pamamaraan

Tandaan na ang mga tagalikha ng Java ay nagsulat ng isang buong klase ng helper na tinatawag Arrayspara sa aming kaginhawahan kapag nagtatrabaho sa mga array?

Ginawa nila ang parehong bagay para sa mga koleksyon. Ang Java ay may isang java.util.Collectionsklase na may maraming mga pamamaraan na kapaki-pakinabang para sa pagtatrabaho sa mga koleksyon. Narito lamang ang mga pinaka-kawili-wili:

Paraan Paglalarawan 
addAll(colls, e1, e2, e3, ...)
 Idinaragdag ang mga elemento e1, e2, e3, ... sa collskoleksyon 
fill(list, obj)
 Pinapalitan ang lahat ng elemento sa naipasa na listahan ngobj 
nCopies(n, obj)
 Nagbabalik ng listahan ng nmga kopya ng objbagay 
replaceAll(list, oldVal, newVal)
 Pinapalitan ang lahat ng instance ng oldValsa newVallistahanlist 
copy(dest, src)
 Kinokopya ang lahat ng elemento mula sa srclistahan patungo sa destlistahan 
reverse(list)
 Binabaliktad ang listahan. 
sort(list)
 Pinag-uuri-uri ang listahan sa pataas na pagkakasunud-sunod 
rotate(list, n)
 Paikot na inililipat ang mga elemento ng listlistahan ayon sa nmga elemento 
shuffle(list)
 Random na sina-shuffle ang mga elemento sa listahan 
min(colls)
 Hinahanap ang pinakamababang elemento sa collskoleksyon 
max(colls)
 Hinahanap ang maximum na elemento sa collskoleksyon 
frequency(colls, obj)
 Tinutukoy kung gaano karaming beses objnaganap ang elemento sa collskoleksyon 
binarySearch(list, key)
 Hinahanap sa keyisang pinagsunod-sunod na listahan at ibinabalik ang kaukulang index. 
disjoint(colls1, colls2)
 Ibinabalik truekung ang mga koleksyon ay walang magkakatulad na elemento
Mahalaga:

Marami sa mga pamamaraang ito ay hindi gumagamit ng ArrayList, HashSetat HashMapmga klase per se, ngunit may kaukulang mga interface: Collection<T>, List<T>, Map<K, V>.

Ito ay hindi isang problema: kung ang isang pamamaraan ay tumatanggap ng isang List<T>, maaari mong palaging ipasa ito ng isang ArrayList<Integer>, ngunit ang assignment operator ay hindi gumagana sa kabaligtaran na direksyon.

Java webinar

2. Paglikha at pagbabago ng mga koleksyon

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

Ang addAll()pamamaraan ay nagdaragdag ng mga elemento e1, e2, e3, ... sa collskoleksyon Anumang bilang ng mga elemento ay maaaring maipasa.

Code Output ng console 
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)paraan

Pinapalitan ng fill()pamamaraan ang lahat ng elemento ng listkoleksyon ng objelemento.

Code Output ng console 
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)paraan

Ang nCopies()pamamaraan ay nagbabalik ng isang listahan ng nmga kopya ng objelemento. Tandaan na ang ibinalik na listahan ay hindi nababago, na nangangahulugang hindi mo ito mababago! Magagamit mo lang ito para magbasa ng mga value:

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

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

for(String s: list)
   System.out.println(s);
 Gumawa ng hindi nababagong listahan ng 5 Hellostring
Lumikha ng nababago listat punan ito ng mga value mula sa immutableListlistahan.

Output ng console:
Hello
Hello
Hello
Hello
Hello

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

Pinapalitan ng replaceAll()pamamaraan ang lahat ng elemento sa listkoleksyon na katumbas oldValueng newValue.

Code Output ng console 
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)paraan

Kinokopya ng copy()pamamaraan ang lahat ng elemento ng srckoleksyon sa destkoleksyon.

Kung destmagsisimula ang koleksyon nang mas mahaba kaysa sa koleksyon, mananatiling buo srcang natitirang mga elemento ng koleksyon.dest

Mahalaga:
Ang destkoleksyon ay dapat na hindi bababa sa kahabaan ng srckoleksyon (kung hindi, isang IndexOutOfBoundsExceptionitatapon).
Code Output ng console 
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. Pagkakasunod-sunod ng mga elemento

Collections.reverse(List<T> list)paraan

Binabaliktad ng reverse()pamamaraan ang pagkakasunud-sunod ng mga elemento ng naipasa na listahan.

Code Output ng console 
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)paraan

sort()Inuuri ng pamamaraan ang naipasa na listahan sa pataas na pagkakasunud-sunod.

Code Output ng console 
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)paraan

Paikot na inililipat ng rotate()pamamaraan ang mga elemento ng naipasa na listahan sa pamamagitan ng distancemga posisyong pasulong.

Code Output ng console 
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)paraan

Ang shuffle()pamamaraan ay random na binabasa ang lahat ng mga elemento ng naipasa na listahan. Ang resulta ay naiiba sa bawat oras.

Code Output ng console 
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. Paghahanap ng mga elemento sa mga koleksyon

Collections.min(Collection<T> colls)paraan

Ibinabalik ng min()pamamaraan ang pinakamababang elemento sa koleksyon.

Code Output ng console 
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)paraan

Ibinabalik ng max()pamamaraan ang maximum na elemento sa koleksyon.

Code Output ng console 
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)paraan

Binibilang ng frequency()pamamaraan ang bilang ng beses objna nangyari ang elemento sa collskoleksyon

Code Output ng console 
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)paraan

Hinahanap ng binarySearch()pamamaraan ang objelemento sa collskoleksyon. Ibinabalik ang index ng nahanap na elemento. Nagbabalik ng negatibong numero kung hindi natagpuan ang elemento.

Mahalaga:
Bago tawagan ang binarySearch()pamamaraan, ang koleksyon ay dapat ayusin (gamitin Collections.sort()).
Code Output ng console 
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)paraan

Ang disjoint()pamamaraan ay babalik truekung ang mga naipasa na mga koleksyon ay walang anumang mga elemento na magkakatulad.

Code Output ng console 
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