Vinkkejä Java-ohjelmointiin

Tälle sivulle on koottu Java-ohjelmointiin liittyvää tietoa, josta voi olla hyötyä kurssilla. Monet asioista ovat esiintyneet myös ainakin ohimennen ohjelmoinnin peruskursseilla, mutta ne eivät ehkä ole enää tuoreessa muistissa.

Lukujen käsittely

Kokonaisluvut

Javan tavallisimmat kokonaislukutyypit ovat int ja long. Tyyppi int on 32-bittinen, ja siinä olevan luvun suuruus voi olla noin 2 · 109. Tyyppi long on puolestaan 64-bittinen, ja siinä olevan luvun suuruus voi olla noin 9 · 1018.

Yleensä hyvä valinta kokonaisluvun tyypiksi on int. Jos sen arvoalue on liian pieni, voi käyttää suurempaa tyyppiä long.

Jos käytetyn tyypin arvoalue loppuu kesken, tapahtuu ylivuoto (overflow), mikä näkyy usein siinä, että koodin tuloksena on negatiivinen luku, vaikka sellaista ei pitäisi tulla. Näin käy esimerkiksi seuraavassa koodissa:

int a = 123456789;
int b = 987654321;
System.out.println(a*b); // -67153019

Tässä on ongelmana, että laskun tulos ei mahdu int-tyyppiin. Ongelman voi korjata käyttämällä long-tyyppiä:

long a = 123456789;
long b = 987654321;
System.out.println(a*b); // 121932631112635269

Seuraavassa koodissa on vielä yksi sudenkuoppa:

long x = 123456789*987654321;
System.out.println(x); // -67153019

Nyt vaikka muuttujan x tyyppi on long, kertolasku lasketaan edelleen int-tyypillä. Yksi tapa korjata asia on muuttaa toinen luvuista long-tyyppiseksi näin:

long x = (long)123456789*987654321;
System.out.println(x); // 121932631112635269

Kuten tästä näkyy, long-tyypin käyttäminen vaatii tarkkuutta. Usein jos koodi antaa outoja tuloksia, jossain kohtaa on kuitenkin käytetty vahingossa int-tyyppiä.

Liukuluvut

Javan tavallisin liukulukutyyppi on 64-bittinen double. Liukulukujen etuna on, että niissä voi olla desimaaliosa:

double x = 12.527;

Liukuluvuissa on kuitenkin ongelmana, että niissä tapahtuu pyöristysvirheitä. Seuraava koodi havainnollistaa asiaa:

double x = 3*0.3+0.1;
double y = 1;
if (x == y) System.out.println("x ja y ovat samat");
if (x < y) System.out.println("x on pienempi kuin y");
if (x > y) System.out.println("x on suurempi kuin y");

Vaikka x:n ja y:n arvon pitäisi olla sama, koodi tulostaa x on pienempi kuin y. Syynä on, että laskua 3*0.3+0.1 ei pystytä laskemaan tarkasti, vaan x:n arvoksi tulee hieman alle 1.

Tämän vuoksi liukulukuja kannattaa välttää aina kun mahdollista. Yleensä löytyy jokin tapa, miten algoritmin voi toteuttaa tarkasti ilman liukulukuja.

Lause vs. lauseke

Lause (statement) on ohjelmassa oleva komento, kun taas lauseke (expression) on jokin koodin osa, jolla on arvo. Esimerkiksi System.out.println(a+b) on lause, jonka osana on lauseke a+b.

Javassa melko moni lauseelta näyttävä ilmaisu on itse asiassa lauseke, jolla on arvo. Esimerkiksi sijoitus a = b on lauseke, jonka arvona on b. Seuraava koodi samaan aikaan sijoittaa muuttujan a arvoksi 5 ja tulostaa arvon.

int a = 3;
System.out.println(a = 5); // 5

Muutos yhdellä

Lausekkeet a++ ja ++a kasvattavat molemmat a:n arvoa yhdellä, mutta a++ on arvoltaan a, kun taas ++a on arvoltaan a+1. Seuraavat koodit havainnollistavat asiaa:

int a = 3;
System.out.println(a++); // 3
System.out.println(a); // 4
int a = 3;
System.out.println(++a); // 4
System.out.println(a); // 4

Ehdollinen lauseke

Ehdollinen lauseke a ? b : c on arvoltaan b, jos ehto a pätee, ja muuten c. Esimerkiksi seuraavassa koodissa ehdollisen lausekkeen arvo on "parillinen", jos ehto x%2 == 0 pätee (eli x on parillinen), ja muuten "pariton".

int x;
// ...
String s = x%2 == 0 ? "parillinen" : "pariton";

Taulukko

Javan perustietorakenne on taulukko, joka muodostuu peräkkäin olevista alkioista. Taulukon alkiot on numeroitu kokonaisluvuin 0, 1, 2, jne., ja niihin viitataan [] -merkinnän avulla.

Taulukko on hyvä valinta algoritmien toteuttamisessa, jos sen ominaisuudet riittävät, koska se on paljon kevyempi kuin esimerkiksi ArrayList-rakenne.

Taulukon käsittely

Seuraava koodi luo taulukon luvut, jossa on 5 alkiota. Jokainen arvo on aluksi 0.

int[] luvut = new int[5];

Toinen tapa luoda taulukko on antaa sen alkiot listana:

int[] luvut = {3,1,5,2,5};

Taulukon alkioita voi käsitellä samaan tapaan kuin tavallisia muuttujia:

luvut[0] = 2;
luvut[1] = 5;
luvut[2] = luvut[0]+luvut[1];

Taulukon tulostaminen

Taulukon tulostaminen vaatii hieman työtä, koska seuraava koodi ei toimi halutusti:

int[] luvut = {1,2,3};
System.out.println(luvut); // [I@3cd1a2f1

Taulukon pystyy kuitenkin tulostamaan näin:

int[] luvut = {1,2,3};
System.out.println(Arrays.toString(luvut)); // [1, 2, 3]

Viittaukset ja kopiointi

Javassa on kahdenlaisia muuttujia: alkeistyypin muuttujat (esim. int) ja oliomuuttujat (esim. taulukko). Näiden muuttujien käsittelyssä on tärkeä ero: alkeismuuttujien arvo kopioidaan sijoituksessa ja metodin parametrina, mutta oliomuuttujasta kopioidaan vain viittaus.

Esimerkiksi seuraavassa koodissa ei ole mitään yllättävää:

int a = 3;
int b = a;
b = 5;
System.out.println(a); // 3

Kuitenkin kun saman koodin toteuttaa taulukoilla, tulee yllättävämpi tulos:

int[] a = {1,2,3};
int[] b = a;
b[0] = 5;
System.out.println(a[0]); // 5

Tässä a ja b viittaavat samaan taulukkoon, eli kun taulukkoa b muuttaa, niin muutos heijastuu myös taulukkoon a. Tämä on hyvin yleinen syy bugeihin Java-ohjelmissa.

Jos taulukosta halutaan tehdä aito kopio, jonka muuttaminen ei vaikuta alkuperäiseen taulukkoon, ratkaisu on käyttää metodia clone:

int[] a = {1,2,3};
int[] b = a.clone();
b[0] = 5;
System.out.println(a[0]); // 1

Merkkijonot

Merkki vs. merkkijono

Merkki (char) on yksittäinen symboli, kuten kirjain tai numero. Merkki kirjoitetaan koodissa heittomerkkien sisään.

Merkkijono (String) on jono peräkkäin olevia merkkejä. Merkkijono kirjoitetaan koodissa lainausmerkkien sisään.

char c = 'a';
String s = "apina";

Metodi charAt antaa tietyssä kohtaa merkkijonoa olevan merkin:

String s = "apina";
System.out.println(s.charAt(1)); // p

Merkkijonojen vertailu

Seuraava koodi ei toimi oikein, jos a ja b ovat merkkijonoja, koska ==-operaattori vertailee viittauksia eikä sisältöjä.

if (a == b) {
    // ...
}

Toimiva vertailu on käyttää metodia equals:

if (a.equals(b)) {
    // ...
}

Merkkijonon muuttaminen

Javassa merkkijonoa ei voi muuttaa sen luomisen jälkeen, vaan ainoa tapa on luoda uusi merkkijono. Esimerkiksi +=-operaattori luo uuden merkkijonon kopioimalla sen pohjaksi alkuperäisen merkkijonon sisällön. Seuraavan koodin seurauksena muistissa on kolme merkkijonoa: "apina", "x" ja "apinax".

String s = "apina";
s += "x";

Seuraava koodi on erittäin tehoton tapa luoda merkkijono, jossa on miljoona a-merkkiä:

String s = "";
for (int i = 0; i < 1000000; i++) {
    s = s+"a";
}

Ongelmana on, että silmukan jokainen askel luo uuden merkkijonon, eli koodi luo merkkijonot "a", "aa", "aaa", jne. Tässä kuluu paljon aikaa ja muistia. Tehokas tapa on käyttää StringBuilder-luokkaa tai char-taulukkoa merkkijonon luomiseen.

int vs. Integer

Javassa alkeistyyppien (kuten int) rinnalla on vastaavia oliotyyppejä (kuten Integer), jotka ovat omiaan aiheuttamaan sekaannusta.

Oliotyypit ovat välttämätön paha Javan tietorakenteissa. Esimerkiksi kun luomme ArrayList-rakenteen, jonka sisältönä on int-lukuja, tyypiksi tulee antaa Integer:

ArrayList<Integer> luvut = new ArrayList<>();

Java tekee usein automaattisia muunnoksia tyyppien välillä. Esimerkiksi seuraava koodi toimii mainiosti, vaikka luvut sisältää Integer-lukuja ja koodi käyttää int-lukuja:

luvut.add(1);
luvut.add(2);
luvut.add(3);
int x = luvut.get(0);

Huomaa kuitenkin, että seuraava koodi ei ole toimiva:

if (luvut.get(0) == luvut.get(1)) {
    // ...
}

Tässä ei tapahdu muunnosta int-tyypiksi, vaan Java vertailee Integer-lukuja. Nyt ==-operaattori ei toimi halutusti, vaan vertailu tulee tehdä equals-metodilla:

if (luvut.get(0).equals(luvut.get(1))) {
    // ...
}

Asiaa mutkistaa vielä se, että ==-vertailu saattaa toimia näennäisesti, kun luvut ovat pieniä (esim. välillä –128...127), koska Java voi silloin vertailla niitä eri tavalla. Bugi tulee kuitenkin esille silloin, kun koodi käsittelee suurempia lukuja.

static-muuttujat

Luokassa oleva static-muuttuja on yhteinen kaikille luokasta luotaville olioille. Sen arvo säilyy tallessa olioiden välillä, toisin kuin tavallisen muuttujan arvo. Tarkastellaan esimerkkinä seuraavaa luokkaa:

public class Testi {
    static int a;
    int b;
    
    void tulosta() {
        a++; b++;
        System.out.println(a + " " + b);
    }
}

Kun luokasta luodaan kaksi oliota, muuttuja a on niille yhteinen, kun taas kummallakin oliolla on oma muuttuja b:

Testi x = new Testi();
x.tulosta(); // 1 1
Testi y = new Testi();
y.tulosta(); // 2 1

Moni outo bugi testatessa koodia johtuu siitä, että luokassa on käytetty static-muuttujaa. Tällöin tietoa säilyy muuttujissa testien välillä, vaikka testit eivät liity toisiinsa. Ratkaisu on kerrankin helppo: kun sanan static poistaa, niin koodi alkaa toimia moitteetta.

Komentorivin käyttäminen

On hyödyllinen taito osata kääntää ja suorittaa Java-koodi komentorivillä. Tällöin ohjelmoijalla on täysi kontrolli asioihin, toisin kuin IDEä (esim. NetBeans) käyttäessä.

Seuraavat esimerkit olettavat, että käytössä on Linux-ympäristö. Muissa ympäristöissä komentoriviä käytetään melko samalla tavalla.

Käännös ja suoritus

Seuraava komento kääntää tiedostossa Koodi.java olevan luokan:

javac Koodi.java

Tästä syntyy käännetty tiedosto Koodi.class, jonka voi suorittaa näin:

java Koodi

Komentoriviparametrit

Metodin main parametrina oleva taulukko args sisältää parametrit, jotka ohjelmalle on annettu komentorivillä. Seuraava ohjelma tulostaa kaikki parametrinsa:

public class Koodi {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(i + " " + args[i]);
        }
    }
}

Voimme testata ohjelmaa suorittamalla se näin:

java Koodi apina banaani cembalo

Nyt ohjelman tulostus on seuraava:

0 apina
1 banaani
2 cembalo