Ang simula ng paraan
Ngayon gusto kong pag-usapan ang tungkol sa isang kawili-wiling paksa tulad ng "
Java Collections Framework " o, sa simpleng mga termino, tungkol sa mga koleksyon. Karamihan sa gawain ng code ay nagpoproseso ng data sa isang anyo o iba pa. Kumuha ng listahan ng mga user, kumuha ng listahan ng mga address, atbp. Kahit papaano ay pag-uri-uriin ang mga ito, magsagawa ng paghahanap, ihambing ang mga ito. Ito ang dahilan kung bakit ang kaalaman sa mga koleksyon ay itinuturing na isang pangunahing kasanayan. Kaya naman gusto kong pag-usapan ito. Bilang karagdagan, ang isa sa mga pinakakaraniwang tanong sa mga panayam ng developer ng Java ay mga koleksyon. Halimbawa, "gumuhit ng hierarchy ng mga koleksyon." Tutulungan tayo ng online compiler sa ating paglalakbay. Halimbawa, maaari mong gamitin ang " Tutorialspoint
Online Java Compiler " o
Repl.it. Ang landas sa pagkilala sa anumang istruktura ng data ay nagsisimula sa mga ordinaryong variable (Mga Variable). Sa website ng Oracle, ang iba't ibang paksa ay kinakatawan bilang "mga landas" o Trail. Kaya, ang landas upang makilala ang Java ay tinatawag na "
Trail: Learning the Java Language: Table of Contents ". At ang mga pangunahing kaalaman ng wika (i.e. Mga Pangunahing Kaalaman sa Wika) ay nagsisimula sa Variables. Samakatuwid, magsulat tayo ng isang simpleng code:
public static void main(String[] args) {
String user = "Max";
System.out.println("Hello, " + user);
}
Ito ay mabuti sa lahat, maliban na naiintindihan namin na ang code na ito ay mabuti at maganda para lamang sa isang variable. Ano ang gagawin kung marami sa kanila? Ang mga array ay naimbento upang mag-imbak ng data ng isang uri. Sa parehong Trail mula sa Oracle mayroong isang hiwalay na seksyon na nakatuon sa mga array. Ang seksyong ito ay tinatawag na: "
Arrays ". Ang pagtatrabaho sa mga array ay medyo simple din:
import java.util.Arrays;
class Main {
public static void main(String[] args) {
String[] users = new String[2];
users[0] = "Max";
users[1] = "John";
System.out.println("Hello, " + Arrays.toString(users));
}
}
Ang mga array ay malulutas ang problema ng pag-iimbak ng maramihang mga halaga sa isang lugar. Ngunit ito ay nagpapataw ng isang limitasyon: ang laki ng array ay pare-pareho. Kung, tulad ng sa halimbawa, sinabi namin na ang laki = 2, kung gayon ito ay katumbas ng dalawa. Iyon lang. Kung gusto natin ng mas malaking array, kailangan nating gumawa ng bagong instance. Gayundin, ang paghahanap ng isang elemento ay isa ring nakakalito na bagay para sa isang array. Mayroong isang paraan
Arrays.binarySearch, ngunit ang paghahanap na ito ay gumagana lamang sa isang pinagsunod-sunod na hanay (para sa isang hindi pinagsunod-sunod na hanay, ang resulta ay hindi natukoy o hindi nahuhulaan lamang). Ibig sabihin, obligahin tayo ng paghahanap na pagbukud-bukurin ang bawat oras. Ang pagtanggal din ay nag-clear lamang ng halaga. Samakatuwid, hindi pa rin namin alam kung gaano karaming data ang aktwal na nasa array, alam lang namin kung gaano karaming mga cell ang nasa array. Upang i-refresh ang iyong kaalaman tungkol sa mga array:
At bilang resulta ng pagbuo ng wikang Java, lumitaw ang Java Collections Framework sa JDK 1.2, na pag-uusapan natin ngayon.
Koleksyon
Simulan ang paggastos mula sa simula. Bakit Collections? Ang termino mismo ay nagmula sa mga bagay tulad ng "Type Theory" at "Abstract Data Types". Ngunit kung hindi mo titingnan ang anumang matataas na bagay, kung gayon kapag mayroon tayong maraming bagay, maaari nating tawaging "koleksiyon ng mga bagay." Mga nangongolekta ng mga bagay. Sa pangkalahatan, ang salitang collect mismo ay nagmula sa Lat. collectio "pagtitipon, pagkolekta." Iyon ay, ang isang koleksyon ay isang koleksyon ng isang bagay, isang lalagyan para sa ilang mga elemento. Kaya mayroon kaming isang koleksyon ng mga elemento. Ano ang maaaring gusto nating gawin dito:
Gaya ng nakikita mo, maaaring gusto natin ng medyo lohikal na mga bagay. Naiintindihan din namin na maaaring gusto naming gumawa ng isang bagay na may maraming koleksyon:
Alinsunod dito, isinulat ng mga developer ng Java ang interface ng java.util.Collection upang ilarawan ang pangkalahatang gawi na ito para sa lahat ng mga koleksyon . Ang interface ng Koleksyon ay kung saan nagmula ang lahat ng mga koleksyon. Ang koleksyon ay isang ideya, ito ay isang ideya kung paano dapat kumilos ang lahat ng mga koleksyon. Samakatuwid, ang terminong "Koleksyon" ay ipinahayag bilang isang interface. Naturally, ang isang interface ay nangangailangan ng mga pagpapatupad. Ang interface
java.util.Collectionay may abstract class
AbstractCollection, iyon ay, ilang "abstract collection", na kumakatawan sa skeleton para sa iba pang mga pagpapatupad (tulad ng nakasulat sa JavaDoc sa itaas ng klase
java.util.AbstractCollection). Sa pagsasalita tungkol sa mga koleksyon, bumalik tayo at tandaan na gusto nating ulitin ang mga ito. Nangangahulugan ito na gusto naming ulitin ang mga elemento nang paisa-isa. Ito ay isang napakahalagang konsepto. Samakatuwid, ang interface
Collectionay minana mula sa
Iterable. Ito ay napakahalaga dahil... una, ang lahat ng Iterable ay dapat na maibalik ang isang Iterator batay sa mga nilalaman nito. At pangalawa, lahat ng bagay na Iterable ay maaaring gamitin sa mga loop
for-each-loop. At ito ay sa tulong ng isang iterator
AbstractCollectionna ang mga pamamaraan tulad ng
contains,
toArray, ay ipinatupad
remove. At ang landas sa pag-unawa sa mga koleksyon ay nagsisimula sa isa sa mga pinakakaraniwang istruktura ng data - isang listahan, i.e.
List.
Mga listahan
Kaya, ang mga listahan ay sumasakop sa isang mahalagang lugar sa hierarchy ng mga koleksyon:
Gaya ng nakikita natin, ipinapatupad ng mga listahan ang interface ng
java.util.List . Ipinapahayag ng mga listahan na mayroon kaming isang koleksyon ng mga elemento na nakaayos sa ilang pagkakasunod-sunod. Ang bawat elemento ay may index (tulad ng sa isang array). Karaniwan, pinapayagan ka ng isang listahan na magkaroon ng mga elemento na may parehong halaga. Tulad ng sinabi namin sa itaas,
Listalam nito ang tungkol sa index ng elemento. Binibigyang-daan ka nitong makakuha ng (
get) isang elemento sa pamamagitan ng index o magtakda ng isang halaga para sa isang partikular na index (
set). Ang mga pamamaraan ng koleksyon
add,
addAll,
removeay nagbibigay-daan sa iyo na tukuyin ang index kung saan ipapatupad ang mga ito. Bilang karagdagan, ang y
Listay may sariling bersyon ng isang iterator na tinatawag na
ListIterator. Alam ng iterator na ito ang tungkol sa index ng elemento, kaya maaari itong umulit hindi lamang pasulong, kundi pati na rin pabalik. Maaari pa itong gawin mula sa isang partikular na lugar sa koleksyon. Sa lahat ng mga pagpapatupad, mayroong dalawang pinakakaraniwang ginagamit:
ArrayListat
LinkedList. Una,
ArrayListito ay isang listahan (
List) batay sa isang array (
Array). Binibigyang-daan ka nitong makamit ang "Random Access"
sa mga elemento. Ang random na pag-access ay ang kakayahang agad na makuha ang isang elemento sa pamamagitan ng index, sa halip na dumaan sa lahat ng mga elemento hanggang sa makita namin ang elemento na may nais na index. Ito ay ang array bilang batayan na nagpapahintulot na ito ay makamit. Sa kabaligtaran,
LinkedListito ay isang Linked List. Ang bawat entry sa isang naka-link na listahan ay kinakatawan sa form
Entry, na nag-iimbak ng data mismo, pati na rin ang isang link sa susunod (susunod) at nakaraan (nakaraan)
Entry. Kaya
LinkedListipinapatupad ang "Sequential Access
" . Malinaw na upang mahanap ang ika-5 elemento ay kailangan nating pumunta mula sa unang elemento hanggang sa huli, dahil wala kaming direktang access sa ikalimang elemento. Maa-access lang natin ito mula sa ika-4 na elemento. Ang pagkakaiba sa kanilang konsepto ay ibinigay sa ibaba:
Sa trabaho, tulad ng naiintindihan mo, mayroon ding pagkakaiba. Halimbawa, pagdaragdag ng mga elemento. Ang
LinkedListmga elemento ay konektado lamang tulad ng mga link sa isang kadena. Ngunit
ArrayListnag-iimbak ito ng mga elemento sa isang array. At ang isang array, tulad ng alam natin, ay hindi maaaring baguhin ang laki nito. Paano ito gumagana kung gayon
ArrayList? At ito ay gumagana nang napakasimple. Kapag naubos ang espasyo sa array, tataas ito ng 1.5 beses. Narito ang zoom code:
int newCapacity = oldCapacity + (oldCapacity >> 1); Ang isa pang pagkakaiba sa pagpapatakbo ay ang anumang pag-aalis ng mga elemento. Halimbawa, kapag nagdaragdag o nag-aalis ng mga elemento sa gitna. Upang alisin mula sa
LinkedListisang elemento, alisin lang ang mga sanggunian sa elementong ito. Sa kaso ng ,
ArrayListnapipilitan kaming ilipat ang mga elemento sa bawat oras na ginagamit ang
System.arraycopy. Kaya, mas maraming elemento, mas maraming aksyon ang kailangang gawin. Ang isang mas detalyadong paglalarawan ay matatagpuan sa mga artikulong ito:
Ang pagkakaroon ng pagsusuri sa ArrayList, hindi maaaring hindi maalala ng isa ang "predecessor" nito, ang
java.util.Vector class . Naiiba ito
Vectordahil
ArrayListang mga pamamaraan para sa pagtatrabaho sa koleksyon (pagdaragdag, pagtanggal, atbp.) ay naka-synchronize. Iyon ay, kung ang isang thread (
Thread) ay nagdaragdag ng mga elemento, ang iba pang mga thread ay maghihintay hanggang sa matapos ang unang thread sa trabaho nito. Dahil madalas na hindi kinakailangan ang kaligtasan ng thread, inirerekomendang gamitin ang klase sa mga ganitong kaso
ArrayList, tulad ng tahasang nakasaad sa JavaDoc para sa klase
Vector. Bilang karagdagan,
Vectorpinapataas nito ang laki nito hindi ng 1.5 beses,
ArrayListngunit sa pamamagitan ng 2 beses. Kung hindi, ang pag-uugali ay pareho -
Vectorang imbakan ng mga elemento sa anyo ng isang array ay nakatago at ang pagdaragdag/pag-alis ng mga elemento ay may parehong mga kahihinatnan tulad ng sa
ArrayList. Sa katunayan,
Vectornaalala namin ito para sa isang dahilan. Kung titingnan natin sa Javadoc, makikita natin sa "Mga Direktang Kilalang Subclass" ang isang istraktura tulad ng
java.util.Stack . Ang stack ay isang kawili-wiling istraktura na isang LIFO
last-in-first-out(huling papasok, una sa labas) na istraktura. Ang stack na isinalin mula sa English ay isang stack (tulad ng isang stack ng mga libro, halimbawa). Ang stack ay nagpapatupad ng mga karagdagang pamamaraan:
peek(tumingin, tumingin),
pop(push),
push(push). Ang paraan
peekay isinalin bilang hitsura (halimbawa,
ang pagsilip sa loob ng bag ay isinalin bilang "
tumingin sa loob ng bag ", at
ang pagsilip sa keyhole ay isinalin bilang "
pagsilip sa keyhole "). Ang pamamaraang ito ay nagbibigay-daan sa iyo upang tumingin sa "tuktok" ng stack, i.e. makuha ang huling elemento nang hindi inaalis (i.e. nang hindi inaalis) ito mula sa stack. Ang pamamaraan
pushay nagtutulak (nagdaragdag) ng isang bagong elemento sa stack at ibinabalik ito, at ang paraan ng elemento
popay nagtutulak (nag-aalis) at nagbabalik ng tinanggal. Sa lahat ng tatlong kaso (i.e. silip, pop at push), gumagana lang kami sa huling elemento (ibig sabihin, ang "itaas ng stack"). Ito ang pangunahing tampok ng istraktura ng stack. Sa pamamagitan ng paraan, mayroong isang kawili-wiling gawain upang maunawaan ang mga stack, na inilarawan sa aklat na "A Programmer's Career" (Cracking Coding Interview). Mayroong isang kawili-wiling gawain kung saan gamit ang "stack" structure (LIFO) kailangan mong ipatupad ang "queue ” istraktura (FIFO). Dapat itong magmukhang ganito:
Ang pagsusuri sa gawaing ito ay matatagpuan dito: "
Implement A Queue Using Stacks - The Queue ADT ("Implement Queue Using Stacks" on LeetCode) ". Kaya maayos kaming lumipat sa isang bagong istraktura ng data - isang pila.
Nakapila
Ang Queue ay isang istraktura na pamilyar sa atin mula sa buhay. Nakapila sa mga tindahan, sa mga doktor. Kung sino ang nauna (First In) ang unang aalis sa pila (First Out). Sa Java, ang isang queue ay kinakatawan ng
java.util.Queue interface . Ayon sa Javadoc ng queue, idinaragdag ng queue ang mga sumusunod na pamamaraan:
Tulad ng nakikita mo, may mga pamamaraan ng pag-order (ang hindi pagtupad sa mga ito ay puno ng isang pagbubukod) at may mga pamamaraan ng kahilingan (ang kawalan ng kakayahang maisagawa ang mga ito ay hindi humantong sa mga pagkakamali). Posible ring makuha ang elemento nang hindi ito inaalis (sumilip o elemento). Ang queue interface ay mayroon ding kapaki-pakinabang na kahalili -
Deque . Ito ang tinatawag na "two-way queue". Iyon ay, ang ganitong queue ay nagbibigay-daan sa iyo na gamitin ang istrakturang ito pareho mula sa simula at mula sa dulo. Sinasabi ng dokumentasyon na "Maaari ding gamitin ang Deques bilang LIFO (Last-In-First-Out) stack. Dapat gamitin ang interface na ito bilang kagustuhan sa legacy Stack class.", ibig sabihin, inirerekomendang gamitin ang mga pagpapatupad ng Deque sa halip na salansan. Ipinapakita ng Javadoc kung anong mga pamamaraan ang inilalarawan ng Deque interface:
Tingnan natin kung anong mga pagpapatupad ang mayroon. At makakakita tayo ng isang kawili-wiling katotohanan - ang LinkList ay nakapasok sa kampo ng pila) Ibig sabihin, ipinapatupad ng LinkList ang parehong
List, at
Deque. Ngunit mayroon ding mga "pila lang", halimbawa
PriorityQueue. Hindi siya madalas naaalala, ngunit walang kabuluhan. Una, hindi ka maaaring gumamit ng "hindi maihahambing na mga bagay" sa pila na ito, i.e. dapat tukuyin ang alinman sa Comparator o ang lahat ng bagay ay dapat na maihahambing. Pangalawa, "ang pagpapatupad na ito ay nagbibigay ng oras ng O(log(n)) para sa mga pamamaraan ng enqueuing at dequeuing". May dahilan ang logarithmic complexity. Ipinatupad ang PriorityQueue batay sa heap. Sinasabi ng Javadoc: "Ang priyoridad na pila ay kinakatawan bilang isang balanseng binary heap". Ang imbakan mismo para dito ay isang regular na hanay. Na lumalaki kung kinakailangan. Kapag maliit ang bunton, tataas ito ng 2 beses. At pagkatapos ay sa pamamagitan ng 50%. Komento mula sa code: "Dobleng laki kung maliit; kung hindi ay lalago ng 50%". Ang priority queue at Binary Heap ay magkahiwalay na paksa. Kaya para sa karagdagang impormasyon:
Ang isang pagpapatupad
java.util.Dequeay maaaring ang
java.util.ArrayDeque class . Iyon ay, ang mga listahan ay maaaring ipatupad gamit ang isang naka-link na listahan at isang array, at ang mga pila ay maaari ding ipatupad gamit ang isang array o gamit ang isang naka-link na listahan.
QueueAng at mga interface
Dequeay may mga inapo na kumakatawan sa "blocking queue":
BlockingQueueat
BlockingDeque. Narito ang pagbabago ng interface kumpara sa mga regular na pila:
Tingnan natin ang ilang halimbawa ng pagharang sa mga pila. Ngunit sila ay kawili-wili. Halimbawa, ang BlockingQueue ay ipinatupad ng:
PriorityBlockingQueue ,
SynchronousQueue , ArrayBlockingQueue,
DelayQueue ,
LinkedBlockingQueue . Ngunit
BlockingDequeipinapatupad nila ang lahat mula sa karaniwang Collection Frameworks
LinkedBlockingDeque. Ang bawat pila ay ang paksa ng isang hiwalay na pagsusuri. At sa loob ng balangkas ng pagsusuring ito, ilalarawan namin ang hierarchy ng klase hindi lamang sa
List, kundi pati na rin sa
Queue:
Tulad ng nakikita natin mula sa diagram, ang mga interface at klase ng Java Collections Framework ay lubos na magkakaugnay. Magdagdag tayo ng isa pang sangay ng hierarchy -
Set.
Itakda
Set— isinalin bilang “set.” Naiiba ito sa isang queue at isang listahan
Setsa mas malaking abstraction nito sa pag-iimbak ng mga elemento.
Set- tulad ng isang bag ng mga bagay, kung saan hindi alam kung paano matatagpuan ang mga bagay at sa anong pagkakasunud-sunod ng mga ito. Sa Java, ang naturang set ay kinakatawan ng
java.util.Set interface . Tulad ng sinasabi ng dokumentasyon,
Setito ay isang "koleksyon na walang mga dobleng elemento". Kapansin-pansin, ang interface mismo
Setay hindi nagdaragdag ng mga bagong pamamaraan sa interface
Collection, ngunit nililinaw lamang ang mga kinakailangan (tungkol sa kung ano ang hindi dapat maglaman ng mga duplicate). Bilang karagdagan, mula sa nakaraang paglalarawan ay sumusunod na hindi ka maaaring
Setmakakuha ng isang elemento mula dito. Ang iterator ay ginagamit upang makakuha ng mga elemento.
Setay may ilang higit pang mga interface na nauugnay dito. Ang una ay
SortedSet. Tulad ng iminumungkahi ng pangalan,
SortedSetipinapahiwatig nito na ang naturang set ay pinagsunod-sunod, at samakatuwid ang mga elemento ay nagpapatupad ng interface
Comparableo tinukoy
Comparator. Bilang karagdagan,
SortedSetnag-aalok ito ng ilang mga kagiliw-giliw na pamamaraan:
Bilang karagdagan, mayroong mga pamamaraan
first(pinakamaliit na elemento ayon sa halaga) at
last(pinakamalaking elemento ayon sa halaga). May
SortedSettagapagmana -
NavigableSet. Ang layunin ng interface na ito ay upang ilarawan ang mga paraan ng pag-navigate na kailangan upang mas tumpak na matukoy ang mga naaangkop na elemento. Ang isang kawili-wiling bagay ay
NavigableSetang pagdaragdag nito sa karaniwang iterator (na napupunta mula sa pinakamaliit hanggang sa pinakamalaki) ng isang iterator para sa reverse order -
descendingIterator. Bilang karagdagan,
NavigableSetpinapayagan ka nitong gamitin ang paraan
descendingSetupang makakuha ng pagtingin sa iyong sarili (View), kung saan ang mga elemento ay nasa reverse order. Ito ay tinatawag
Viewdahil sa pamamagitan ng nagresultang elemento maaari mong baguhin ang mga elemento ng orihinal
Set. Iyon ay, sa esensya, ito ay isang representasyon ng orihinal na data sa ibang paraan, at hindi isang kopya nito. Kapansin-pansin,
NavigableSetang , tulad ng
Queue, ay kayang humawak ng
pollFirst(minimal) at
pollLast(maximal) na mga elemento. Iyon ay, nakukuha nito ang elementong ito at inaalis ito sa set. Anong uri ng mga pagpapatupad ang naroon? Una, ang pinakatanyag na pagpapatupad ay batay sa isang hash code -
HashSet . Ang isa pang pantay na kilalang pagpapatupad ay batay sa isang pulang-itim na puno -
TreeSet . Kumpletuhin natin ang aming diagram:
Sa loob ng mga koleksyon, nananatili itong ayusin ang hierarchy - ang mga hermit. Na sa unang tingin ay tumatabi -
java.util.Map.
Mga mapa
Ang mga mapa ay isang istraktura ng data kung saan iniimbak ang data sa pamamagitan ng key. Halimbawa, ang susi ay maaaring isang ID o code ng lungsod. At ito ay sa pamamagitan ng key na ito na ang data ay hahanapin. Ito ay kagiliw-giliw na ang mga card ay ipinapakita nang hiwalay. Ayon sa mga developer (tingnan ang "
Java Collections API Design FAQ "), ang key-value mapping ay hindi isang koleksyon. At ang mga mapa ay mas mabilis na maituturing na isang koleksyon ng mga susi, isang koleksyon ng mga halaga, isang koleksyon ng mga pares ng key-value. Ito ay isang kawili-wiling hayop. Anong mga pamamaraan ang ibinibigay ng mga kard? Tingnan natin ang interface ng Java API
na java.util.Map . kasi Dahil ang mga mapa ay hindi mga koleksyon (hindi sila nagmana mula sa Mga Koleksyon), hindi sila naglalaman ng isang
contains. At ito ay lohikal. Ang isang mapa ay binubuo ng mga susi at halaga. Alin sa mga ito ang dapat suriin ng pamamaraan
containsat kung paano hindi malito? Samakatuwid, ang interface
Mapay may dalawang magkaibang bersyon:
containsKey(naglalaman ng susi) at
containsValue(naglalaman ng halaga). Ang paggamit nito
keySetay nagbibigay-daan sa iyo na makakuha ng isang hanay ng mga susi (parehong susi
Set). At gamit ang pamamaraan
valuesmakakakuha tayo ng isang koleksyon ng mga halaga sa mapa. Ang mga susi sa mapa ay natatangi, na binibigyang-diin ng istruktura ng data
Set. Maaaring ulitin ang mga halaga, na binibigyang-diin ng istraktura ng data ng Koleksyon. Bilang karagdagan, gamit ang pamamaraan
entrySetmaaari tayong makakuha ng isang hanay ng mga pares ng key-value. Maaari kang magbasa nang higit pa tungkol sa kung anong mga pagpapatupad ng card ang mayroon sa mga pinakadetalyadong pagsusuri:
Gusto ko ring makita kung ano ang
HashMaphalos kapareho sa
HashSet, at
TreeMapsa
TreeSet. Mayroon pa silang magkatulad na mga interface:
NavigableSetat
NavigableMap,
SortedSetat
SortedMap. Kaya ang aming huling mapa ay magiging ganito:
Maaari nating tapusin ang kawili-wiling katotohanan na
Setpanloob na ginagamit ng koleksyon
Map, kung saan ang mga idinagdag na halaga ay mga susi, at ang halaga ay pareho sa lahat ng dako. Ito ay kagiliw - giliw dahil
Maphindi ito isang koleksyon at mga pagbabalik
Set, na isang koleksyon ngunit sa katunayan ay ipinatupad bilang
Map. Medyo surreal, ngunit iyon ang nangyari)
Konklusyon
Ang magandang balita ay dito nagtatapos ang pagsusuring ito. Ang masamang balita ay ito ay isang napaka-review na artikulo. Ang bawat pagpapatupad ng bawat isa sa mga koleksyon ay nararapat sa isang hiwalay na artikulo, at para din sa bawat algorithm na nakatago sa ating mga mata. Ngunit ang layunin ng pagsusuri na ito ay alalahanin kung ano ang mga ito at kung ano ang mga koneksyon sa pagitan ng mga interface. Umaasa ako na pagkatapos ng maalalahanin na pagbabasa ay magagawa mong gumuhit ng isang diagram ng mga koleksyon mula sa memorya.
Well, gaya ng dati, ilang link:
#Viacheslav
GO TO FULL VERSION