Java:Kogumid

Kogumid (ingl Collections) on andmestruktuurid, mis hoiavad objektide hulka.

Massiiv

Massiiv (array) on kõige lihtsam kogumitüüp. Peaaegu kõik teised kogumid saab realiseerida massiivide peal (ja seda paljud reaalselt ka kasutavad). Massiiv on fikseeritud pikkusega kogum - peale massiivi loomist pikkust enam muuta ei saa. Massiivi kõik elemendid peavad olema sama tüüpi (või alamtüüpi). Massiivis saab kasutada ka primitiivseid andmetüüpe elementidena.

Elementide indeksid hakkavad 0-st. Ehk siis massiivi esimese elemendi indeks on 0 jne.

Massiiv on tegelikult objekt, aga kuna seda kasutatakse väga tihti, siis massiiviga opereerimiseks on loodud erandlik süntaks.

Massiivi esimene element massiiv[0]

Massiivi pikkus massiiv.length

Massiivi viimane element massiiv[massiiv.length - 1]

Koodnäide:

<source lang="java"> int[] massiiv = new int[10]; massiiv[0] = 1; massiiv[9] = 10; //massiiv[10] ei mahu enam massiivi, kuna on 11. element

System.out.println(massiiv[0]); // 1 System.out.println(massiiv[1]); // 0 - int massiivi element on vaikimisi 0

// algväärtustame 1..10 for (int i = 0; i < massiiv.length; i++) { massiiv[i] = i + 1; // indeks liigub 0..9, väärtused 1..10 } // leiame elementide summa int sum = 0; for (int i = 0; i < massiiv.length; i++) { sum = sum + massiiv[i]; } System.out.println("Massiivi elementide summa: " + sum); </source>

Sõne massiivid: <source lang="java"> String[] nimed = {"Mati", "Kati", "Jüri"}; String otsi = "Jüri"; boolean found = false; for (int i = 0; i < nimed.length; i++) { if (otsi.equals(nimed[i])) { System.out.println(otsi + " leitud! indeks: " + i); found = true; break; // lõpetame otsimise ära } } // for-each tüüpi tsükkel: for (String s : nimed) { System.out.println(s); } if (!found) { System.out.println("Nime " + otsi + " ei leitud."); } </source>

Geneerilised tüübid

Nagu massiivi puhul nägime, hoitakse selles konkreetset tüüpi elemente (kõik näiteks int või String). Sarnaselt on järgmiste kogumite juures vaja märkida, millst tüüpi elemente kogumis hoitakse. Kogumites hoitakse ainult objekte, ehk siis primitiivseid andmetüüpe (nagu int või double) järgnevalt näidatavates kogumites hoida ei saa. Selle asemel tuleb kasutada näiteks vastavaid objekte: Integer või Double. Geneeriline tüüp (ehk geneerik) märgitakse < ja > märkide vahele. Näiteks List<Integer> või Set<String>.

Loend

Loend (list) on korrastatud (järjekord säilib) andmekogum. Kui lisada elemendid loendisse, siis hiljem on nad lugemisel täpselt samas järjekorras kui neid sisestati.

Javas on implementeeritud erinevaid loendeid. Kirjelame siin ArrayList tüüpi loendit.

ArrayList

ArrayList on dünaamiline massiv. Tüütab suuresti nagu massiiv (on sisemiselt realiseeritud massiiviga), kuid pikkus on dünaamiline. Ehk siis ArrayList'i loomise hetkel ei pea teadma, palju loendisse on vaja lisada. Loend suureneb ise vastavalt vajadusele.

Koodinäide:

<source lang="java"> import java.util.ArrayList;

public class ArrayListExample {

public static void main(String[] args) { ArrayList<Integer> numbrid = new ArrayList<Integer>(); numbrid.add(1); numbrid.add(2); System.out.println(numbrid.size()); // 2

numbrid.add(3); numbrid.add(4); // loend: 1, 2, 3, 4 System.out.println(numbrid.size()); // 4

System.out.println(numbrid.get(1)); // 2

numbrid.remove(1); // element indeksiga 1 eemaldatakse // ülejäänud loendi elemendid liigutatakse ühe võrra ettepoole: // loend: 1, 3, 4

numbrid.add(1, 2); // lisame elemendi "2" positsioonile 1 // kõik elemendid indeksiga 1 või suuremad nihutatakse ühe võrra edasi: // loend: 1, 2, 3, 4

numbrid.set(1, 7); // asendame elemendi väärtuse positsioonil 1: // loend: 1, 7, 3, 4

numbrid.clear(); // tühjendame // numbrid 1..10 for (int i = 0; i < 10; i++) { numbrid.add(i + 1); } // prindime välja for (int i = 0; i < numbrid.size(); i++) { System.out.println(numbrid.get(i)); }

}

} </source>

Hulk

Hulk (ingl set) ei sisalda elementide kordusi. Hulk pole järjestatud - elementide küsimine hulgast võib iga kord anda erineva järjestuse. Javas on järjekordselt palju erinevaid hulkasid, vaatleme siinkohal HashSet kogumit.

HashSet

Hulka saab lisada elemente. Korduva elemendi lisamisel uut elementi ei lisata. Tulemusena on hulk, kus igat elementi on maksimaalselt 1.

Koodinäide: <source lang="java"> import java.util.HashSet;

public class HashSetExample {

public static void main(String[] args) { HashSet<Integer> set = new HashSet<Integer>();

// lisame kaks elementi set.add(1); set.add(2); System.out.println(set.size()); // lisame veel ühe (korduva elemendi) set.add(1); System.out.println(set.size());

// aga kus on set.get(1)?

/* * Set on kogum, millel puudub järjekord. * Seetõttu pole ka defineeritud, milline element on esimene, * milline on teine jne. Seega elemente ei saa indeksi järgi küsida. * Aga kuidas printida välja kõik elemendid? * Siin on üks näide, kuidas seda teha läbi massiivi. */ // muudame hulga massiiviks:

// toArray võtab argumendiks massiivi ning kasutab // väljundmassiivina sama tüüpi massiivi. // kuigi sisendiks on massiiv, mille pikkus on 0, // siis väljundis on automaatselt nii pikk massiiv, // et kõik elemendid mahuks ära. Integer[] numbers = set.toArray(new Integer[0]);

// for-each tüüpi tsükkel for (int n : numbers) { System.out.println(n); } }

} </source>

Nagu näha, puudub hulgal võimalus elementi indeksi järgi küsida (vrdl list.get(i)). See tuleneb sellest, et elemendid pole järjestatud - pole määratud, mis on esimene element, mis on teine jne. Selleks, et hulga elemente saaks järjest läbi käia, kasutatakse iteraatorit.

Iteraator

Iteraator (ingl iterator) on liides andmekogumi süstemaatiliseks läbikäimiseks. Iteraator töötab nagu kursor teksti lugemisel. Kursor on alguses kogumi alguses. Kui sealt üks element ära loetakse, liigub kursor järgmise elemendi algusesse jne. Iteraatoril on kaks peamist meetodit:

• boolean hasNext() - tagastab true, kui iteraatoris on järgmine element olemas. Ehk siis kas kursori positsioonile järgneb midagi. Kui kogum on läbi saanud, siis tagastab false. Selle meetodi väljakutsumine ei liiguta kursorit.
• E next() - loeb järgmise elemendi (kursor liigub edasi). Saadud objekti andmetüüp on see, mis on määratud Iterator objekti loomisel.

Koodinäide HashSet'iga kasutamisel:

<source lang="java"> import java.util.HashSet; import java.util.Iterator;

public class SetIterator {

public static void main(String[] args) {

// teeme hulga sõnedest HashSet<String> words = new HashSet<String>(); // paneme sinna mõned sõnad words.add("word"); words.add("world"); words.add("word"); System.out.println(words.size());

// iterator objekt Iterator<String> it = words.iterator(); // tsükkel, mida korratakse seni, kuni järgmine element eksisteerib while (it.hasNext()) { // .next() annab järgmise elemendi String word = it.next(); System.out.println(word); } }

} </source>

Iteraator luuakse kujul Iterator<E>, kus E märgib ära andmetüübi, mida hakatakse lugema andmekogumist. Seda tüüpi objekti tagastab ka next() meetod. Meie viimases näites loodi HashSet sõnedest. Kuna selle hulga iga element on sõne, siis ka iteraatorile tuleb seda öelda. Selleks on märgitud andmetüübiks Iterator<String> it = words.iterator(); .

Kujutis

Kujutis (ingl map) on andmekogum, kus võtmete hulga igale elemendile on vastavuses üks väärtuste hulga element. Võib vaadelda nii, et kujutis sisaldab kaheosalisi kirjeid, mille esimest komponenti nimetatakse võtmeks ja teist väärtuseks. Ühe võtmega elemente võib olla vaid üks. Kasutatakse juhul, kui on vaja kiiresti mingi väärtuse (võtme) järgi üles leida teist väärtust. Võtit ja väärtust võib vaadelda ka kui seost - võti on seotud väärtusega. Vaatame konkreetset realisatsiooni HashMap.

HashMap

HashMap hoiab konkreetsele võtmele vastavat väärtust kasutades selleks paisktabelit.

Koodinäide: <source lang="java"> import java.util.HashMap; import java.util.Iterator; import java.util.Map.Entry;

public class HashMapExample {

public static void main(String[] args) { // tikumängu näide. mitu "1" palli meil on? HashMap<Integer, Integer> balls = new HashMap<Integer, Integer>();

// lisame elemendi. määrame võtme ja väärtuse balls.put(1, 3); // palle "1" on meil 3 tükki balls.put(2, 12); // palle "2" on meil 12 tükki balls.put(5, 10); // palle "5" on meil 10 tükki

System.out.println(balls.size());

System.out.println(balls.get(2)); // mitu palli "2" meil on System.out.println(balls.get(3)); // mitu palli "3" meil on?

// kuidas printida välja kõik elemendid? // 1) for-each tüüpi tsükkel ainult väärtustest for (Integer count : balls.values()) { System.out.println(count); } // aga nii ei saa me teada, mis number palli kohta mingi kogus käib

// 2) for-each tüüpi tsükkel võtmest ja väärtusest for (Entry<Integer, Integer> entry : balls.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); }

// iteraator Iterator<Entry<Integer, Integer>> it = balls.entrySet().iterator(); while (it.hasNext()) { Entry<Integer, Integer> entry = it.next(); System.out.println(entry.getKey() + ": " + entry.getValue()); }

// kui tahame lisada ühe "4" palli (praegu neid pole üldse): balls.put(4, 1); // kui tahame lisada ühe "1" palli (suurendame pallide arvu): int count = balls.get(1); balls.put(1, count + 1); // kirjutame uue väärtuse, mis on ühe võrra suurem

// kuidas lugeda kokku, mitu palli meil on? // peame kõik väärtused läbi käima ja kokku liitma int sum = 0; for (Entry<Integer, Integer> entry : balls.entrySet()) { sum += entry.getValue(); } System.out.println("Palle kokku:" + sum); } } </source>

HashMap kirjeldatakse ära kujul: HashMap<K, V> name = new HashMap<K, V>();, kus K viitab võtme objektile ja V viitab väärtuse objektile. Nagu näha, siis võtmete ja väärtuste andmetüübid määratakse kohe alguses ära. Seega läbi terve kujutise võib kasutada vaid sama tüüpi võtmeid ja väärtusi.

Olulisemad meetodid:

• map.put(K, V) - väärtus V lisatakse võtmega K kohale. Näiteks map.put("tere", 3); .
• map.size() - võti-väärtus seoste arv (võib mõelda ka kas lihtsalt võtmete arv või väärtuste arv).
• V map.get(K) - tagastab etteantud võtmega, mille andmetüüp on K, väärtuse, mille andmetüüp on V. K ja V andmetüübid on määratud HashMap'i loomise ajal.