Course Mga Koleksyon ng Java - Lecture: Mga koleksyon

"Narito ako."

"Matagal na kitang hinihintay dito."

"Sana nga. Let's carry on, then."

"Ipapakilala kita para ipakita sa iyo ang isang super-duper full-feature na utility class para sa mga koleksyon."

"Nanginginig na ako sa sobrang kilig."

"Mahusay. Pagkatapos ay magsimula na tayo. Narito ang mga pamamaraan ng klase ng Collections:"

Code	Paliwanag
`boolean addAll(Collection<? super T> c, T... elements)`	Idinaragdag ang mga naipasa na elemento sa naipasa na koleksyon. Ang pamamaraang ito ay maaaring maginhawang tawaging ganito: Collections.addList (listahan, 10,11,12,13,14,15)
`Queue<T> asLifoQueue(Deque<T> deque)`	Nagbabalik ng «normal na pila» na ginawa mula sa isang deque.
`int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)`	Nagsasagawa ng binary na paghahanap para sa pangunahing elemento sa listahan. Dapat ayusin ang listahan. Maaari mong tukuyin ang isang comparator upang ihambing ang mga elemento.
`Collection<E> checkedCollection(Collection<E> c, Class<E> type)`	Sinusuri na ang lahat ng elemento ng koleksyon c ay nasa isang tiyak na uri. Ang mga katulad na pamamaraan ay umiiral para sa Listahan, Mapa, Itakda, at SortedSet.
`void copy(List<? super T> dest, List<? extends T> src)`	Kinokopya ang src list sa dest list.
`boolean disjoint(Collection<?> c1, Collection<?> c2)`	Sinusuri na ang mga koleksyon ay hindi naglalaman ng mga karaniwang elemento
`void fill(List<? super T> list, T obj)`	Pinunan ang listahan ng elementong obj
`int frequency(Collection<?> c, Object o)`	Binibilang kung ilang beses umiiral ang object o sa koleksyon c
`int indexOfSubList(List<?> source, List<?> target)`	Tinutukoy ang index ng unang paglitaw ng listahan ng target sa loob ng listahan ng pinagmulan. Ang prinsipyo ay katulad ng String.indexOf("some string")
`int lastIndexOfSubList(List<?> source, List<?> target)`	Tinutukoy ang index ng huling paglitaw ng listahan ng target sa loob ng listahan ng pinagmulan. Katulad ng String.lastIndexOf("some string")
`T max(Collection<? extends T> coll)`	Hinahanap ang maximum na bilang/halaga sa isang koleksyon. Paano natin mahahanap ang maximum na 6 na numero? Collections.max(Arrays.asList(51, 42, 33, 24, 15, 6));
`T min(Collection<? extends T> coll)`	Hinahanap ang pinakamababang halaga sa isang koleksyon.
`List<T>nCopies(int n, To)`	Gumagawa ng dummy na koleksyon kung saan lumilitaw ang elementong o n beses.
`boolean replaceAll(List<T> list, T oldVal, T newVal)`	Pinapalitan ang lahat ng oldVal na elemento sa listahan ng mga newVal na elemento
`void reverse(List<?> list)`	Binabaliktad ang listahan.
`void shuffle(List<?> list)`	Random na sina-shuffle ang mga elemento ng listahan.
`List<T>singletonList(To)`	Nagbabalik ng hindi nababagong listahan na binubuo ng isang naipasa na elemento. May mga katulad na pamamaraan para sa Map, Set, at SortedSet.
`void sort(List<T> list)`	Pinagbukud-bukod ang listahan sa pataas na pagkakasunud-sunod.
`void swap(List<?> list, int i, int j)`	Pinapalitan ang mga elemento ng listahan
`Collection<T>synchronizedCollection(Collection<T> c)`	Binabalot ang koleksyong ito sa isang naka-synchronize na katapat. Ang mga katulad na pamamaraan ay umiiral para sa Listahan, Mapa, Itakda, at SortedSet.

"Whoa! Oo, ito ay isang buong arsenal, at halos hindi ko nagamit ang alinman dito."

"Actually, dito na nagtatapos ang lesson ko ngayon."

"Tingnan ang mga pamamaraang ito, at hanapin ang mga pinakamalamang na gagamitin mo."

"O mas mabuti pa, pag-aralan mo sila. Magiging kapaki-pakinabang sila sa iyo."

"Salamat, Rishi. Mag-aaral na ako."