I200:Muutujad

Muutuja on sisuliselt nagu kast, kuhu asju sisse panna. Java nõuab, et sellel kastil oleks nimi ja tüüp. Nimeks pane mida ise soovid, et sa ise ära tunneks ja tüüpidest räägime all pikemalt.

Näiteks kui soovime lapse vanust salvestada, siis sobib selleks int (integer, ehk täisarv) tüüp ja "vanus" nimi:

Seda kirjutaksime Javas järgnevalt:

int vanus = 5;

Kui sooviksin selle lapse nime salvestada, kasutaksin tüüpi String, ehk sõne:

String nimi = "Mikk";

Väikese tähega andmetüübid (int) on primitiivid ja suure tähega (String) on objektid. Vahe on selles, et primitiivne tüüp salvestab lihtsaid andmeid nagu arv või täht, aga objektid salvestavad keerulisemaid andmeid nagu lause. Teine erinevus on see, et objektidel on omad meetodid, mis lihtsustavad toiminguid. Primitiivsetel tüpidel tuleb kasutada abistavaid klasse.

Andmetüüpe on kahte sorti. Ühed salvestavad ühe ainsa väärtuse, teised aga kogumiku väärtusi.

Üksik väärtus

	hoitav väärtus	näide	kuidas uus luua	liitmine
byte	väikesed arvud (-128 kuni 127)	25	byte a = 25;	byte b = (byte) (34 + 3);
int	täisarvud (alates -2'147'483'648 kuni 2'147'483'647)	54	int a = 54;	int a = 34 + 45;
float	reaalarvud (alates 1.4*10^-45 kuni 3.4*10^38)	3	float a = 3;	float a = 34 + 45;
double	reaalarvud (komakohaga) (alates 4.9*10^-324 kuni 1.79*10^308)	65.34	double a = 65.34;	double a = 34 + 45;
char	üks täht	't'	char a = 't';	char a = 't' + 'a'; // a = Õ
String	Sõne, ehk jutumärkide vahele saab panna kõiki sümboleid	"Tere"	String a = "Tere";	String a = "Tere, " + "hommikust!";
boolean	true või false	true	boolean a = true;	boolean a = true && false; // false boolean a = true || false; // true
any Object	keerulisemad objektid, nagu ArrayList	[34, "ArrayList", 47.5]	ArrayList a = new ArrayList();	X

Ettevaatust 1: Arvu miinimum ja maksimum

Igal arvu andmetüübil on oma miinimum ja maksimum võimalik arv, mida andmetüüp suudab hoida. Näiteks kui sul on <byte a = 127>, siis <a + 1> toob tulemuseks -128, sest arv jätkub teisest otsast.

Ettevaatust 2: Arvutused ei ole alati täpsed

Võtame lihtsa tehte: 2.0 - 1.1 = 0.9. Ainult, et tegelikult tuleb Javas vastuseks 0.899999999999999. Kohati uskumatu, et selline viga on sees. Seda esineb ka teistes riistvaralähedastest keeltes.

Lahenduseks on kas kasutada int tüüpi muutujaid (näiteks 23.34€ on 2334) või BigDecimal klassi arvutusteks. Näide kuidas 2.0 - 1.1 korrektselt ära teha. Pane tähele, et arvud on jutumärkide sees, ilma nendeta tuleksid ikka valed vastused.

BigDecimal a = new BigDecimal("2.0");
BigDecimal b = new BigDecimal("1.1");
BigDecimal c = a.subtract(b);
System.out.println("c = " + c); // c = 0.9

String

String, ehk sõne, objektil on meetode, ehk käsklusi, et lauseid ja sõnu oleks lihtne manipuleerida.

String s = "Tere"; // Loome uue sõne

s.contains("ere"); // Kas sõnes s esineb tähekombinatsiooni "ere"?
s.toUpperCase(); // Muuda kõik tähed suureks
s.toLowerCase(); // Muuda kõik tähed väikseks
s.split(" "); // Poolita sõne tühiku kohalt. Tulemuseks on sõnede massiiv.
s.replace("Tere", "Nägemist"); // Otsi sõna "Tere" ja asenda see sõnega "Nägemist"
s.replaceAll(regex, "uus väärtus"); // Kasulik <replace()> sarnane töövahend, aga esmalt uuri välja misasi on regex.
s.isEmpty(); // Kas sõne on tühi?
s.indexOf("re"); // Mis indeksil on sõne "re"? Antud juhul tuleb vastuseks 2
s.length(); // Mitu tähte on sõne pikk?
s.charAt(0); // Mis täht asub indeksil 0?
s.equals(b); // Kas sõne s on sama sisuga mis sõne b?

Kogumik väärtusi

Sissejuhatus

Kui andmete kogus suureneb oleks mõistlik saja muutuja asemel kasutada ühte nimekirja. Näiteks kui on spordivõistlused ja võistleja nr 1 tegi 10 katset. Siis 10 muutuja asemel saan öelda:

int[] võistleja1 = {76, 56, 75, 45, 56, 76, 65, 67, 45, 54};

Kujuta ette, kui võistlejaid on samuti kümme ja igaühel on 10 tulemust. Siis jällegi ei ole meil tarvis kümmet muutujat vaid ühte head HashMapi, mille sees on omakorda ArrayList:

HashMap tulemused = new HashMap();                  // Loo HashMap
ArrayList voistleja = new ArrayList();              // Loo ArrayList
for (int i = 0; i < 10; i++) {                      // iga võistleja kohta
    voistleja.clear();                              // tühjenda eelnevad katsed
    for (int j = 0; j < 10; j++) {                  // iga katse kohta
        voistleja.add((int) (Math.random() * 100)); // genereeri katse tulemus ArrayListi sisse
    }
    tulemused.put("võistleja"+i, voistleja);        // lisa ArrayList HashMapi sisse
}
System.out.println("tulemused = " + tulemused);

Antud koodi tulemuseks on ilus tabel

   tulemused = {
       võistleja2 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja1 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja0 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja6 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja5 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja4 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja3 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja9 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja8 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54],
       võistleja7 = [54, 17, 25, 16, 10, 98, 86, 92, 10, 54]
   }

Kui mul on siis hiljem vaja näiteks võistleja nr 6 tulemust nr 7, siis küsin selle välja ühe reaga:

int t = (int) ((ArrayList) tulemused.get("võistleja6")).get(7);

See üks rida on muidugi suhteliselt keeruline, aga andmed on meil vähemalt struktureeritud ja korras.

Kolm tüüpi

Javas on kolm põhilist andmetüüpi andmete salvestamiseks:

Massiivid

Kõige lihtsamini kasutatav, aga samas kõige paindumatum. Massiivid salvestavad nimekirja ainult ühte andmetüüpi korraga ja nimekirja pikkus ei ole muudetav pärast esmast käivitamist.

ArrayList

Kasutamine ei ole nii otsekohene, kui massiividega, aga nimekirja pikkus muutub vastavalt sisule ja oskab salvestada erinevaid andmetüüpe ühes nimekirjas.

HashMap

Veidi keerulisemat tüüpi nimekiri, aga samas keerulise programmi juures lihtsustab protsesse tohutult! Salvestab <võti: väärtus> tüüpi kirjeid. Näiteks saaks teha sõnaraamatut: "car" -> "auto", "window" -> "aken".

Head ja halvad omadused võrdluses

	massiiv	ArrayList	HashMap
kasutamise keerukus	lihtne	keerukam	veel keerukam
nimekirja pikkus	lukus pärast esimest kasutamist	muutub vastavalt sisule	muutub vastavalt sisule
salvestab andmetüüpe	lukus ühele tüübile	salvestab tüüpe segamini	salvestab <tüüp1: tüüp2> väärtusi
<võti: väärtus> tüüpi	X	X	jah
tulemuse näide	[54, 65, 23]	[65, "sõne", "veel sõne"]	{ "Peeter": 35, "Mari": 38, "Janika": 13, "Mikk": 4 }
maatriksi näide, ehk kogum kogumi sees	[ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]	[ "sõne", ["sõne", "massiivi", "sees"], "arv on ka", 456 ]	{ "Milvi": { "vanus": 25, "elukoht": "Põlva" }, "Laika": { "vanus": 66, "elukoht": "Kosmos" }, }

Kuidas koodis kasutada

	massiiv	ArrayList	HashMap
loo uus tüübita	X	ArrayList a = new ArrayList();	HashMap a = new HashMap();
loo uus tüübiga	int[] a = new int[pikkus]; int[] a = {1, 2, 3}; String[] a = new String[pikkus]; String[] a = {"kohe", "sõned", "sees"};	ArrayList<Integer> a = new ArrayList(); ArrayList<String> a = new ArrayList();	HashMap<String, Integer> a = new HasMap<>();
küsi kirje väärtus	a[i]	a.get(i)	a.get(võti)
asenda kirje	a[i] = b	a.set(i, b)	a.put(võti, väärtus)
lisa element	X	a.add(väärtus)	a.put(võti, väärtus)
eemalda element	X	a.remove(väärtus)	a.remove(võti)
tühjenda	X	a.clear()	a.clear()
nimekirja pikkus	a.length	a.size()	a.size()
kas sisu on võrdne?	Arrays.equals(a, b)	a.equals(b)	a.equals(b)
kmis indeksil on väärtus?	X	a.indexOf()	X
sorteeri tähestiku järg	Arrays.sort(a)	Collections.sort(a)	X
kas sisaldab?	X	a.contains()	a.containsKey(); a.containsValue();
System.out.println(a)	Arrays.toString(a)	a	a
kas on tühi?	X	a.isEmpty()	a.isEmpty()