Ohjelmoinnin perusteet

1. Huomautus lukijalle

Tämä materiaali on tarkoitettu Helsingin yliopiston tietojenkäsittelytieteen laitoksen syksyn 2012 Ohjelmoinnin perusteet- ja jatkokurssille. Materiaali pohjautuu keväiden 2012, 2011 ja 2010 kurssimateriaaleihin, joiden sisältöön ovat vaikuttaneet Matti Paksula, Antti Laaksonen, Pekka Mikkola, Juhana Laurinharju, Martin Pärtel, Joel Kaasinen ja Mikael Nousiainen

Lue materiaalia siten, että teet samalla itse kaikki lukemasi esimerkit. Esimerkkeihin kannattaa tehdä pieniä muutoksia ja tarkkailla, miten muutokset vaikuttavat ohjelman toimintaan. Äkkiseltään voisi luulla, että esimerkkien tekeminen myös itse ja niiden muokkaaminen hidastaa opiskelua. Tämä ei kuitenkaan pidä ollenkaan paikkansa. Ohjelmoimaan ei ole vielä tietääksemme kukaan ihminen oppinut lukemalla (tai esim. luentoa kuuntelemalla). Oppiminen perustuu oleellisesti aktiiviseen tekemiseen ja rutiinin kasvattamiseen. Esimerkkien ja erityisesti erilaisten omien kokeilujen tekeminen on parhaita tapoja "sisäistää" luettua tekstiä.

Pyri tekemään tai ainakin yrittämään tehtäviä sitä mukaa kuin luet tekstiä. Jos et osaa heti tehdä jotain tehtävää, älä masennu, sillä saat ohjausta tehtävän tekemiseen pajassa (tai MOOC-kurssilaisena verkossa).

Tekstiä ei ole tarkoitettu vain kertaalleen luettavaksi. Joudut varmasti myöhemmin palaamaan jo aiemmin lukemiisi kohtiin tai aiemmin tekemiisi tehtäviin. Tämä teksti ei sisällä kaikkea oleellista ohjelmointiin liittyvää. Itse asiassa ei ole olemassa mitään kirjaa josta löytyisi kaikki oleellinen. Eli joudut joka tapauksessa ohjelmoijan urallasi etsimään tietoa myös omatoimisesti. Kurssin harjoitukset sisältävät jo jonkun verran ohjeita, mistä suunnista ja miten hyödyllistä tietoa on mahdollista löytää.

Muutamiin kohtiin olemme myös liittäneet screencasteja joita katsomalla voi pelkän valmiin koodin lukemisen sijaan seurata miten ohjelma muodostuu.

2. Ohjelma ja lähdekoodi

2.1 Lähdekoodi

Ohjelma muodostuu lähdekoodista. Tietokone suorittaa lähdekoodissa olevia komentoja pääsääntöisesti ylhäältä alaspäin ja vasemmalta oikealle. Lähdekoodi talletetaan tekstimuodossa ja suoritetaan jollakin tavalla.

2.2 Komennot

Varsinaisesti ohjelma muodostuu lähdekoodiin kirjoitetuista komennoista. Tietokone suorittaa eri operaatioita, eli toimintoja, komentojen perusteella. Esimerkiksi merkkijonon, eli tekstin, "Hei maailma"-tulostuksessa tärkein komento on System.out.println.

System.out.println("Hei maailma");

Komento System.out.println tulostaa sille sulkeiden sisällä annetun merkkijonon. Pääte ln on lyhenne sanasta line. Komento siis tulostaa rivin, eli kun annettu merkkijono on tulostettu, tulostaa komento myös rivinvaihdon.

2.3 Kääntäjä ja tulkki

Tietokone ei suoraan ymmärrä käyttämäämme ohjelmointikieltä. Tarvitsemme lähdekoodin ja tietokoneen väliin kääntäjän. Ohjelmoidessamme komentoriviä käyttäen, komento javac Hei.java kääntää Hei.java-tiedoston tavukoodiksi, jota voidaan ajaa java-tulkin avulla. Käännetty ohjelma ajetaan komentoriviltä komennolla java Hei, missä Hei on käännetyn java-lähdekooditiedoston nimi.

Käyttäessämme modernia ohjelmointiympäristöä (tästä myöhemmin lisää), ohjelmointiympäristö hoitaa lähdekoodin kääntämisen. Valitessamme ohjelman suorittamisen, ohjelmointiympäristö kääntää ja suorittaa ohjelman. Ohjelmointiympäristöt kääntävät ohjelmakoodia ohjelmoijan sitä kirjoittaessa, jolloin yksinkertaiset virheet huomataan ennen ohjelman suoritusta.

2.4 Komennon osia

2.4.1 Puolipiste

Puolipisteellä ; erotetaan komennot toisistaan. Kääntäjä ja tulkki ei siis ole kiinnostunut lähdekoodissa olevista riveistä, vaan voimme kirjoittaa koko ohjelman yhdelle riville.

Alla olevassa esimerkissä käytetään komentoa System.out.print, joka on kuten komento System.out.println ilman rivinvaihtoa. System.out.print-komento ei siis tulosta rivinvaihtoa tekstin tulostamisen jälkeen.

Esimerkki puolipisteiden käytöstä

System.out.print("Hei "); System.out.print("maailma");
System.out.print("!");

Hei maailma!

Vaikka kääntäjä ja tulkki eivät tarvitse rivinvaihtoja, on niiden käyttö hyvin tärkeää muita ihmisiä ajatellen. Selkeä lähdekoodin osien erottelu vaatii rivinvaihtojen käyttöä. Tätä ja muita lähdekoodin luettavuuteen liittyviä seikkoja tullaan painottamaan tällä kurssilla.

2.4.2 Komennoille lähdetettävät "tiedot" eli parametrit

Komennon käsittelemä tieto eli komennon parametrit lähetetään komennolle lisäämällä ne komennon nimen perässä olevien sulkujen () sisään. Esimerkiksi System.out.print -komennon parametriksi annetaan teksti hei seuraavasti: System.out.print("hei").

2.4.3 Kommentit

Lähdekoodin kommentit ovat kätevä tapa merkitä asioita itselle ja muille muistiin. Kommentti on mikä tahansa rivi, joka alkaa kahdella vinoviivalla //. Kaikki kommenttimerkkiä seuraava samalla rivillä oleva teksti tulkitaan kommentiksi.

2.4.4 Esimerkki kommenttien käytöstä

// Tulostamme tekstin "Hei maailma"
System.out.print("Hei maailma");

System.out.print(" ja kaikki sen ihmiset."); // Lisäämme samalle riville tekstiä.

// System.out.print("tätä riviä ei suoriteta koska se on kommentoitu ulos");

Esimerkissä alin rivi esittelee erityisen kätevän käyttökohteen kommenteille: kirjoitettua koodia ei tarvitse poistaa jos haluaa tilapäisesti kokeilla jotain.

2.5 Lisää tulostamisesta

Kuten aiemmin huomattiin, tulostamiseen on kaksi komentoa:

• System.out.print tulostaa tekstin ilman loppurivinvaihtoa
• System.out.println tulostaa tekstin ja loppurivinvaihdon

Tulostettavan tekstin osana voi olla erikoismerkkejä. Tärkein näistä on \n, joka vaihtaa riviä. Erikoismerkkejä on muitakin.

System.out.println("Ensimmäinen\nToinen\nKolmas");

Ylläoleva tulostaa suoritettaessa seuraavaa:

Ensimmäinen
Toinen
Kolmas

2.6 Pääohjelmarunko

Ohjelman "Esimerkki" runko on seuraavanlainen.

public class Esimerkki {
    public static void main(String[] args) { 
        // ohjelmakoodi
    }
}

Ohjelma sijaitsee samannimisessä .java-päätteisessä tiedostossa. Ohjelman Esimerkki täytyy siis sijaita tiedostossa, jonka nimi on Esimerkki.java.

Ohjelmaa suoritettaessa suoritetaan alue, joka on rungossamme merkitty kommentilla ohjelmakoodi. Ohjelmoimme ensimmäisellä viikolla vain tälle alueelle. Kun puhumme komennoista, esimerkiksi tulostamisesta, tulee komennot kirjoittaa ohjelmarungon sisälle. Esimerkiksi System.out.print("Tulostettava teksti");

public class Esimerkki {
    public static void main(String[] args) {
        System.out.print("Tulostettava teksti");
    }
}

Jatkossa esimerkeissä ei erikseen näytetä pääohjelmarunkoa.

2.7 Tutustuminen ohjelmointiympäristöön

Oskari Opiskelija

Hei Maailma!
(Ja Mualima!)

    *
   ***
  *****
 *******
*********
    *

3. Muuttuja ja sijoitus

3.1 Muuttujat ja tietotyypit

Ohjelmoinnissa eräs keskeinen käsite on muuttuja. Muuttuja kannattaa ajatella lokerona, johon voi tallettaa tietoa. Muuttujaan talletettavalla tiedolla on aina tyyppi. Tyyppejä ovat esimerkiksi teksti eli merkkijono (String), kokonaisluku (int), liukuluku (double) ja totuusarvo (boolean). Muuttujaan asetetaan arvo yhtäsuuruusmerkillä (=).

int kuukausia = 12;

Yllä olevassa asetuslauseessa asetetaan kokonaisluku-tyyppiä (int) olevaan muuttujaan nimeltä kuukausia arvo 12. Asetuslause luetaan "muuttuja kuukausia saa arvon 12".

Muuttujan arvo voidaan yhdistää merkkijonoon +-merkillä seuraavan esimerkin mukaisesti.

String teksti = "sisältää tekstiä";
int kokonaisluku = 123;
double liukuluku = 3.141592653;
boolean onkoTotta = true;

System.out.println("Tekstimuuttujan arvo on " + teksti);
System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku);
System.out.println("Liukulukumuuttujan arvo on " + liukuluku);
System.out.println("Totuusarvomuuttujan arvo on " + onkoTotta);

Tulostus:

Tekstimuuttujan arvo on sisältää tekstiä
Kokonaislukumuuttujan arvo on 123
Liukulukumuuttujan arvo on 3.141592653
Totuusarvomuuttujan arvo on true

Muuttuja säilyttää arvonsa kunnes siihen asetetaan toinen arvo. Huomaa että muuttujan tyyppi kirjoitetaan vain kun muuttuja esitellään ohjelmassa ensimmäistä kertaa.

int kokonaisluku = 123;
System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku);

kokonaisluku = 42;
System.out.println("Kokonaislukumuuttujan arvo on " + kokonaisluku);

Tulostuu:

Kokonaislukumuuttujan arvo on 123
Kokonaislukumuuttujan arvo on 42

3.2 Muuttujan tyyppi pysyy

Kun muuttujan tyyppi on kertaalleen määritelty, ei se enää muutu. Esimerkiksi merkkijonomuuttuja ei voi muuttua kokonaislukumuuttujaksi, eikä siihen voi asettaa kokonaislukua.

String merkkijono = "tsuppadui!";
merkkijono = 42; // Ei onnistu! :(

Liukulukuun voi asettaa kokonaisluvun, sillä kokonaisluku on myös liukuluku

double liukuluku = 0.42;
liukuluku = 1; // Onnistuu! :)

Kanoja:
3
Pekonia (kg):
5.5
Traktori:
Ei ole!

Tässä vielä tiivistelmä:
3
5.5
Ei ole!

Kanoja:
9000
Pekonia (kg):
0.1
Traktori:
Zetor

Tässä vielä tiivistelmä:
9000
0.1
Zetor

3.3 Sallittu ja kuvaava muuttujan nimi

Muuttujan nimeämistä rajoittavat tietyt ehdot. Vaikka muuttujan nimessä voidaan käyttää ääkkösiä, on parempi olla kayttamatta niita, sillä merkistökoodauksesta saattaa tulla ongelmia.

Muuttujan nimessä ei saa olla tiettyjä erikoismerkkejä, kuten huutomerkkejä (!). Välilyönti ei ole sallittu, sillä se erottaa komentojen osat toisistaan. Välilyönti kannattaa korvata camelCase-tyylillä, jolloin nimi muistuttaneeKamelia. Huom! Muuttujien nimien ensimmäinen kirjain kirjoitetaan aina pienellä:

int camelCaseMuuttuja = 7;

Numeroita voidaan käyttää muuttujan nimessä, kunhan nimi ei ala numerolla. Nimi ei myöskään voi koostua pelkistä numeroista.

int 7muuttuja = 4; // Ei sallittu!
int muuttuja7 = 4; // Sallittu, mutta ei kuvaava muuttujan nimi

Muuttujan nimi ei myöskään saa olla jo entuudestaan käytössä. Tälläisiä nimiä ovat mm. aikaisemmin määritellyt muuttujat ja komennot, kuten System.out.print ja System.out.println.

int camelCase = 2;
int camelCase = 5; // Ei sallittu -- muuttuja camelCase on jo käytössä!

Muuttuja kannattaa nimetä siten, että sen käyttötarkoitus on selvää ilman kommentteja tai miettimistä. Tällä kurssilla muuttujat pitää nimetä kuvaavasti.

3.3.1 Sallittuja muuttujien nimiä

• kuukaudenViimeinenPaiva = 20
• ensimmainenVuosi = 1952
• nimi = "Matti"

3.3.2 Virheellisiä muuttujien nimiä

• kuukauden viimeinen päivä = 20
• 1paiva = 1952
• varo! = 1910
• 1920 = 1

4. Laskentaa

Laskentaoperaatiot ovat varsin suoraviivaisia: +, -, * ja /. Erikoisempana operaationa on %, joka on jakojäännös, eli modulo. Laskentajärjestys on myös varsin suoraviivainen: operaatiot lasketaan vasemmalta oikealle sulut huomioon ottaen. Kuitenkin * ja / laskentaan ennen + ja - operaatioita. Tässä vielä tarkemmin laskujärjestyksestä javassa. Linkin takana oleva materiaali ei ole kuitenkaan aloittelijan kannalta kovin oleellista.

int eka = 2; // kokonaislukutyyppinen muuttuja eka saa arvon 2
int toka = 4; // kokonaislukutyyppinen muuttuja toka saa arvon 4
int summa = eka + toka;  // kokonaislukutyyppinen muuttuja summa saa arvon eka + toka, eli 2 + 4

System.out.println(summa); // tulostetaan muuttujan summa arvo

int laskuSuluilla = (1 + 1) + 3 * (2 + 5);   // 23
int laskuSuluitta = 1 + 1 + 3 * 2 + 5;       // 13

Yllä olevan sulkuesimerkin voi suorittaa myös askeleittain.

int laskuSuluilla = (1 + 1);
laskuSuluilla = laskuSuluilla + 3 * (2 + 5)   // 23

int laskuSuluitta = 1 + 1;
laskuSuluitta = laskuSuluitta + 3 * 2;
laskuSuluitta = laskuSuluitta + 5;      // 13

Laskentaoperaatioita voidaan suorittaa lähes missä tahansa kohdassa ohjelmakoodia.

int eka = 2;
int toka = 4;

System.out.println(eka+toka);
System.out.println(2 + toka - eka - toka);

4.1 Liukuluvut eli desimaaliluvut

Kokonaislukujen jako ja jakojäännös ovat hieman hankalampia. Liukuluku ja kokonaisluku menevät helposti sekaisin. Jos kaikki laskuoperaatiossa olevat muuttujat ovat kokonaislukuja, on tulos myös kokonaisluku.

int tulos = 3 / 2;      // tulos on 1 (kokonaisluku), sillä 3 ja 2 ovat myös kokonaislukuja

int eka = 3:
int toka = 2;
double tulos = eka / toka;      // nytkin tulos on 1, sillä eka ja toka ovat kokonaislukuja

Jakojäännös-operaation (%) avulla saadaan selville jakojäännös. Esimerkiksi laskun 7 % 2 jakojäännös on 1.

int jakojaannos = 7 % 2; // jakojaannos on 1 (kokonaisluku)

Jos jakolaskun jakaja tai jaettava (tai molemmat!) ovat liukulukuja, tulee tulokseksi myös liukuluku

double kunJaettavaOnLiukuluku = 3.0 / 2;  // tulokseksi: 1.5
double kunJakajaOnLiukuluku = 3 / 2.0;    // tulokseksi: 1.5

Kokonaisluku voidaan tarvittaessa muuttaa liukuluvuksi lisäämällä sen eteen tyyppimuunnosoperaatio (double):

int eka = 3;
int toka = 2;

double tulos1 = (double)eka / toka;  // tulokseksi: 1.5

double tulos2 = eka / (double)toka;  // tulokseksi: 1.5

double tulos3 = (double)(eka / toka);  // tulokseksi: 1

Jälkimmäisessä tulos pyöristyy väärin sillä laskuoperaatio kokonaisluvuilla suoritetaan ennen tyyppimuunnosta.

Jos jakolaskun tulos asetetaan kokonaislukutyyppiseen muuttujaan, on tulos automaattisesti kokonaisluku

int tulosKokonaislukuKoskaTyyppiKokonaisluku = 3.0 / 2;  // tulos automaattisesti kokonaisluku: 1

Seuraava esimerkki tulostaa "1.5", sillä jaettavasta tehdään liukuluku kertomalla se liukuluvulla (1.0 * 3 = 3.0) ennen jakolaskua.

int jaettava = 3;
int jakaja = 2;

double tulos = 1.0 * jaettava / jakaja;
System.out.println(tulos); 

Mitä seuraava tulostaa?

int jaettava = 3;
int jakaja = 2;

double tulos = jaettava / jakaja * 1.0;
System.out.println(tulos);

Huomioi, että nimeät muuttujat nyt ja jatkossakin yllä esiteltyjen hyvien käytäntöjen mukaan.

Vuodessa on X sekuntia.

5. Katenointi eli merkkijonojen yhdistäminen

Tarkastellaan vielä lähemmin merkkijonojen yhdistämistä +-merkinnän avulla.

Jos operaatiota + sovelletaan kahden merkkijonon välille, syntyy uusi merkkijono, jossa kaksi merkkijonoa on yhdistetty. Huomaa nokkela välilyönnin käyttö lauseen "muuttujien" osana!

String tervehdys = "Hei ";
String nimi = "Matti";
String hyvästely = ", ja näkemiin!";

String lause = tervehdys + nimi + hyvästely;

System.out.println(lause);

Hei Matti, ja näkemiin!

Jos toinen operaation + kohteista on merkkijono, syntyy uusi merkkijono, jossa esimerkiksi kokonaisluku 2 on muutettu merkkijonoksi "2" ja tähän yhdistetty haluttu merkkijono.

System.out.println("tuossa on kokonaisluku --> " + 2);
System.out.println( 2 + " <-- tuossa on kokonaisluku");

Edellä esitellyt laskusäännöt pätevät täälläkin:

System.out.println("Neljä: " + (2+2));
System.out.println("Mutta! kaksikymmentäkaksi: " + 2 + 2);

Neljä: 4
Mutta! kaksikymmentäkaksi: 22

Edellisiä tietoja yhdistelemällä pystymme tulostamaan muuttujan arvoja ja tekstiä sekaisin:

int x = 10;

System.out.println("muuttujan x arvo on: " + x);

int y = 5;
int z = 6;

System.out.println("y on " + y + " ja z on " + z);

Tämä ohjelma tulostaa tietenkin:

muuttujan x arvo on: 10
y on 5 ja z on 6

5 + 4 = 9

73457 + 12888 = 86345

2 * 8 = 16

277 * 111 = 30747

6. Käyttäjän syötteen lukeminen

Tähän asti ohjelmamme ovat olleet kovin yksipuolisia. Seuraavaksi luemme syötettä käyttäjältä. Käytämme syötteen lukemiseen erityistä Scanner-apuvälinettä.

Lisätään Scanner valmiiseen pääohjelmarunkoomme. Älä hätäile vaikka pääohjelmarunko saattaa näyttää vaikeaselkoiselta, jatkamme koodausta kuten ennenkin, eli kohtaan mikä on merkattu kommentilla ohjelmakoodi.

import java.util.Scanner;

public class OhjelmaRunko {

    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        // ohjelmakoodi
    }
}

6.1 Merkkijonon lukeminen

Seuraava koodi lukee käyttäjän nimen ja tulostaa tervehdyksen:

System.out.print("Mikä on nimesi? ");
String nimi = lukija.nextLine(); // Luetaan käyttäjältä rivi tekstiä ja asetetaan se muuttujaan nimi

System.out.println("Hei, " + nimi);

Mikä on nimesi? Matti
Hei, Matti

(Seuraavassa on yllä oleva ohjelma pääohjelmarungon kanssa. Ohjelman nimi on Tervehdys. Koska ohjelman nimi on Tervehdys, täytyy sen sijaita tiedostossa Tervehdys.java -- Käyttäessäsi NetBeans-ohjelmointiympäristöä, toimi kuten alussa olleessa ohjeessa ohjeessa tehtiin, mutta muuta ohjelman nimi Heistä (Hei) Tervehdykseksi (Tervehdys)

import java.util.Scanner;

public class Tervehdys {

    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        System.out.print("Kenelle sanotaan hei: ");
        String nimi = lukija.nextLine(); // Luetaan käyttäjältä rivi tekstiä ja asetetaan sen arvo muuttujaan nimi

        System.out.print("Hei " + nimi);
    }
}

Kun yllä oleva ohjelma ajetaan, pääset kirjoittamaan syötteen. NetBeansin tulostusvälilehti (alhaalla) näyttää ajetun ohjelman jälkeen seuraavalta (käyttäjä syöttää nimen "Matti").

run:
Kenelle sanotaan hei: Matti
Hei Matti
BUILD SUCCESSFUL (total time: 6 seconds)

6.2 Kokonaisluvun lukeminen

Scanner-apuvälineemme ei ole hyvä kokonaislukujen lukemiseen, joten käytämme toista apuvälinettä merkkijonon kokonaisluvuksi muuttamisessa. Komento Integer.parseInt muuttaa sille annetussa tekstimuuttujassa olevan kokonaisluvun kokonaislukumuuttujaksi. Komennolle annetaan tekstimuuttuja sulkuihin, ja se palauttaa kokonaisluvun joka asetetaan kokonaislukumuuttujaan.

Käytännössä kytkemme kaksi komentoa yhteen. Ensin luemme käyttäjältä rivin, jonka annamme heti komennolle Integer.parseInt.

System.out.print("Anna kokonaisluku: ");
int kokonaisluku = Integer.parseInt(lukija.nextLine());

System.out.println("Annoit " + kokonaisluku);

Kysytään seuraavaksi käyttäjältä nimi, ja sen jälkeen ikä. Tällä kertaa esimerkissä on myös ohjelmarunko mukana.

import java.util.Scanner;

public class NimiJaIkaTervehdys {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        System.out.print("Nimesi: ");
        String nimi = lukija.nextLine();   // Luetaan käyttäjältä rivi tekstiä

        System.out.print("Kuinka vanha olet: ");
        int ika = Integer.parseInt(lukija.nextLine()); // luetaan käyttäjältä tekstimuuttuja ja muutetaan se kokonaisluvuksi

        System.out.println("Nimesi on siis: " + nimi + ", ja ikäsi " + ika + ", hauska tutustua.");
    }
}

6.3 Yhteenveto

Käyttäjän kanssa keskustelevan ohjelman runko:

import java.util.Scanner;
public class OhjelmanNimi {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        // koodi tähän
    }
}

Merkkijonon lukeminen:

String merkkijono = lukija.nextLine();

Kokonaisluvun lukeminen:

int kokonaisluku = Integer.parseInt(lukija.nextLine());

Anna ensimmäinen luku: 6
Anna toinen luku: 2

Lukujen summa: 8

Anna ensimmäinen luku: 3
Anna toinen luku: 2

Jakolasku: 3 / 2 = 1.5

Anna ympyrän säde: 20

Ympyrän kehä: 125.66370614359172

Anna ensimmäinen luku: 20
Anna toinen luku: 14

Luvuista suurempi: 20

Kerro nimi: Matti
Kerro ikä: 14

Kerro nimi: Arto
Kerro ikä: 12

Matti ja Arto ovat yhteensä 26 vuotta vanhoja.

import java.util.Scanner;
import nhlstats.NHLStatistics;

public class Paaohjelma {
    public static void main(String[] args) throws Exception {
        Scanner lukija = new Scanner(System.in);

        System.out.println("10 parasta pistemiestä");
        NHLStatistics.sortByPoints();
        NHLStatistics.top(10);
    }
}

10 parasta pistemiestä
Henrik Sedin           VAN        43 11 + 38= 49  36
Phil Kessel            TOR        41 24 + 24= 48  10
Claude Giroux          PHI        36 18 + 30= 48  16
Joffrey Lupul          TOR        41 19 + 28= 47  36
Daniel Sedin           VAN        42 18 + 29= 47  32
Steven Stamkos         TBL        40 28 + 17= 45  34
Marian Hossa           CHI        41 17 + 27= 44  14
Evgeni Malkin          PIT        33 16 + 28= 44  30
Jordan Eberle          EDM        41 17 + 26= 43   6
Jason Pominville       BUF        41 14 + 29= 43   8

NHLStatistics.sortByPoints();     // aseta pelaajat pisteiden mukaiseen järjestykseen
NHLStatistics.sortByGoals();      // aseta pelaajat tehtyjen maalien mukaiseen järjestykseen
NHLStatistics.sortByAssists();    // aseta pelaajat syöttöjen mukaiseen järjestykseen
NHLStatistics.sortByPenalties();  // aseta pelaajat jäähyminuuttien mukaiseen järjestykseen

NHLStatistics.searchByPlayer("Jaromir Jagr");   // tulostaa Jaromir Jagr:in tilastot
NHLStatistics.searchByPlayer("Koivu");          // tulostaa Mikko ja Saku Koivun tilastot
NHLStatistics.searchByPlayer("Teemu");          // tulostaa kaikkien Teemujen tilastot

NHLStatistics.teamStatistics("NYR");            // New York Rangersin tilastot

7. Valinta ja totuusarvot

Tähän mennessä tekemämme ohjelmat ovat edenneet suoraviivaisesti käskystä toiseen, toimien jokaisella suorituskerralla samalla tavalla. Jotta ohjelman suoritus voisi haarautua erilaisille suorituspoluille käyttäjän esim. käyttäjän antaman syötteen perusteella, tarvitsemme käyttöömme valintakäskyn.

int luku = 11;

if ( luku > 10 ) {
    System.out.println("Luku oli suurempi kuin 10");
}

Ehto ( luku > 10 ) muuntautuu totuusarvoksi true tai false. Valintakäsky if käsittelee siis lopulta vain ja ainoastaan totuusarvoja. Yllä oleva ehtolause luetaan "jos luku on suurempi kuin 10".

Huomaa, että if -lauseen perään ei tule puolipistettä, sillä lause ei lopu ehto-osan jälkeen.

Ehdon jälkeen avaava aaltosulku { aloittaa lohkon (block), jonka sisältö suoritetaan jos ehto on tosi. Lohko loppuu sulkevaan aaltosulkuun }. Lohko voi olla kuinka pitkä tahansa.

Vertailuoperaattoreita ovat seuraavat:

• >suurempi kuin
• >=suurempi tai yhtäsuuri kuin
• <pienempi kuin
• <= pienempi tai yhtäsuuri kuin
• == yhtäsuuri kuin
• != erisuuri kuin

int luku = 55;

if ( luku != 0 ) {
    System.out.println("Luku oli erisuuri kuin 0");
}

if ( luku >= 1000 ) {
    System.out.println("Luku oli vähintään 1000");  
}

  

Lohkon sisällä voi olla mitä tahansa koodia, myös toinen valintakäsky.

int x = 45;
int luku = 55;

if ( luku > 0 ) {
    System.out.println("Luku on positiivinen");

    if ( luku>x ) {
        System.out.println(" ja suurempi kuin muuttujan x arvo"); 
        System.out.println("muuttujan x arvohan on " + x);
    }
}

Vertailuoperaattoreita voi käyttää myös ehtojen ulkopuolella. Tällöin ehdon totuusarvo asettuu totuusarvomuuttujaan.

int eka = 1;
int toka = 3;

boolean onkoSuurempi = eka > toka;

Yllä olevassa esimerkissä totuusarvomuuttuja onkoSuurempi sisältää nyt totuusarvon false.

Totuusarvomuuttujaa voidaan käyttää ehtolauseessa ehtona.

int eka = 1;
int toka = 3;

boolean onkoPienempi = eka < toka;

if ( onkoPienempi ) {
    System.out.println("1 on pienempi kuin 3!");
}

  1 on pienempi kuin 3!

7.1 Koodin sisennys

Huomaa, että if-komennon jälkeisen lohkon, eli {-merkkiä seuraavien rivien komentoja ei kirjoiteta samalle tasolle (eli yhtä "vasemmalle") kuin komentoa if, vaan ne sisennetään hieman oikealle. Sisentäminen tapahtuu tabulaattorimerkillä (q:n vasemmalla puolella oleva merkki). Kun lohko sulkeutuu, eli tulee }-merkki, sisennys loppuu. }-merkki on samalla tasolla kuin if.

Sisennys on oleellinen seikka ohjelmien ymmärrettävyyden kannalta. Tällä kurssilla ja kaikkialla "oikeassa elämässä" edellytetään, että koodi sisennetään asiallisesti. NetBeans auttaa sisennyksessä. Ohjelman saa sisennettyä helposti painamalla yhtä aikaa shift, alt ja f.

7.2 else

Jos valinnan ehto on epätotta, eli totuusarvo on false, voidaan suorittaa toinen vaihtoehtoinen lohko koodia, tämä käy komennon else avulla.

int luku = 4;

if ( luku > 5 ) {
    System.out.println("Lukusi on suurempi kuin viisi!");
} else {
    System.out.println("Lukusi on viisi tai alle!");
}

  Lukusi on viisi tai alle!

Anna luku: 5

Luku on positiivinen.

Anna luku: -2

Luku ei ole positiivinen.

Kuinka vanha olet? 12

Et ole vielä täysi-ikäinen!

Kuinka vanha olet? 32

Olet jo täysi-ikäinen!

Anna luku: 2
Luku 2 on parillinen.

Anna luku: 7
Luku 7 on pariton.

7.3 else if

Jos valittavissa olevia vaihtoehtoja on enemmän kuin kaksi kannattaa käyttää else if-komentoa, joka on kuten else, mutta lisäehdolla. else if tulee if-ehdon jälkeen. else if ehtoja voi olla useita.

int luku = 3;

if ( luku == 1 ) {
    System.out.println("Luku on yksi");
} else if ( luku == 2 ) {
    System.out.println("Lukuna on kaksi");
} else if ( luku == 3 ) {
    System.out.println("Kolme lienee lukuna!");
} else {
    System.out.println("Aika paljon!");
}

  Kolme lienee lukuna!

Luetaan ylläoleva esimerkki: 'Jos luku on yksi, tulosta "Luku on yksi", muuten jos luku on kaksi, tulosta "Lukuna on kaksi", muuten jos lukuna on kolme, tulosta "Kolme lienee lukuna". Muulloin, tulosta "Aika paljon!"'.

7.4 Merkkijonojen vertailu

Merkkijonoja, eli tekstejä, ei voi vertailla yhtäsuuri kuin (==) operaatiolla. Merkkijonojen vertailuun käytetään erillistä equals-komentoa, joka liittyy aina verrattavaan merkkijonoon.

String teksti = "kurssi";

if ( teksti.equals("marsipaani") ) {
    System.out.println("Teksti-muuttujassa on teksti marsipaani.");
} else {
    System.out.println("Teksti-muuttujassa ei ole tekstiä marsipaani.");
}

Komento equals liitetään aina siihen verrattavaan tekstimuuttujaan, "tekstimuuttuja piste equals teksti". Tekstimuuttujaa voidaan myös verrata toiseen tekstimuuttujaan.

String teksti = "kurssi";
String toinenTeksti = "pursi";

if ( teksti.equals(toinenTeksti) ) {
    System.out.println("Samat tekstit!");
} else {
    System.out.println("Ei samat tekstit!");
}

Merkkijonoja vertailtaessa on syytä varmistaa että verrattavalla tekstimuuttujalla on arvo. Jos muuttujalla ei ole arvoa, ohjelma tuottaa virheen NullPointerException, joka tarkoittaa ettei muuttujan arvoa ole asetettu tai se on tyhjä (null).

Anna ensimmäinen luku: 5
Anna toinen luku: 3

Suurempi luku: 5

Anna ensimmäinen luku: 5
Anna toinen luku: 8

Suurempi luku: 8

Anna ensimmäinen luku: 5
Anna toinen luku: 5

Luvut ovat yhtä suuret!

Anna pisteet [0-60]: 37

Arvosana: 2

Anna pisteet [0-60]: 51

Arvosana: 5

7.5 Loogiset operaatiot

Valinnan ehto voi olla myös monimutkaisempi, yksittäisten loogisten operaatioiden avulla koostettu ehto. Loogisia operaatioita ovat:

• ehto1 && ehto2 lausekkeen arvo on tosi molemmat ehtoista ovat tosia
• ehto1 || ehto2 lausekkeen arvo on tosi jos jompi kumpi tai molemmat ehdoista tosia
• !ehto lausekkeen arvo on tosi kun ehdon arvo on epätosi

Seuraavassa yhdistetään &&:lla eli ja-operaatiolla kaksi yksittäistä ehtoa, sillä halutaan tarkistaa, onko muuttujassa oleva luku suurempi kuin 4 ja pienempi kuin 11, eli siis välillä 5-10:

System.out.println("Onkohan luku väliltä 5-10: ");
int luku = 7;

if ( luku > 4 && luku < 11 ) {
    System.out.println("On! :)");
} else {
    System.out.println("Ei ollut :(")
}

Onkohan luku väliltä 5-10: 
On! :)

Seuraavassa annetaan ||:n eli tai-operaation avulla kaksi vaihtoehtoa, onko luku pienempi kuin 0 tai suurempi kuin 100. Ehto toteutuu jos luku täyttää jomman kumman ehdon:

System.out.println("Onkohan luku pienempi kuin 0 tai suurempi kuin 100");
int luku = 145;

if ( luku < 0 || luku > 100 ) {
    System.out.println("On! :)");
} else {
    System.out.println("Ei ollut :(")
}

Onkohan luku pienempi kuin 0 tai suurempi kuin 100
On! :)

Seuraavassa käännetään !:n eli negaatio-operaation avulla ehdon arvo päinvastaiseksi:

System.out.println("Eihän merkkijono ole 'maito'");
String merkkijono = "piimä";

if ( !(merkkijono.equals("maito")) ) {  // tosi jos ehto merkkijono.equals("maito") on epätosi
    System.out.println("ei ollut!");
} else {
    System.out.println("oli")
}

ei ollut!

Monimutkaisten ehtojen muodostamisessa tarvitaan usein sulkuja:

int luku = 99;

if ( (luku > 0 && luku < 10) || luku > 100 ) {
    System.out.println("luku oli joko yhden ja yhdeksän väliltä tai yli sata"); 
} else {
    System.out.println("luku oli 0 tai pienempi tai väliltä 10-99");
}

luku oli 0 tai pienempi tai väliltä 10-99

Kuinka vanha olet? 10
OK

Kuinka vanha olet? 55
OK

Kuinka vanha olet? -3
Mahdotonta!

Kuinka vanha olet? 150
Mahdotonta!

Anna tunnus: aleksi
Anna salasana: tappara
Olet kirjautunut järjestelmään

Anna tunnus: elina
Anna salasana: kissa
Olet kirjautunut järjestelmään

Anna tunnus: aleksi
Anna salasana: jokerit
Virheellinen tunnus tai salasana!

Anna vuosi: 2011
Vuosi ei ole karkausvuosi.

Anna vuosi: 2012
Vuosi on karkausvuosi.

Anna vuosi: 1800
Vuosi ei ole karkausvuosi.

Anna vuosi: 2000
Vuosi on karkausvuosi.

8. Toiston alkeet

Valintakomennon avulla saamme ohjelman toimintaan mukaan ehdollisuutta, eli esim. jos käyttäjätunnus ja salasana ovat oikein, päästetään käyttäjä kirjautumaan ohjelmaan ja muuten ei.

Ehdollisuuden lisäksi tarvitsemme toistoa: käyttäjätunnusta ja salasanaa pitää pystyä kysymään uudelleen niin kauan kunnes oikea käyttäjätunnus/salasana-pari on annettu.

Yksinkertaisin toiston muoto on ikuinen toisto. Seuraava ohjelma tulostaa merkkijonoa osaan ohjelmoida! ikuisesti eli "äärettömän monta kertaa":

while ( true ) {
    System.out.println("osaan ohjelmoida!");
}

Komento while( true ) saa sen aikaan, että siihen liittyvää lohkoa, eli {}:lla ympäröityjä komentoja suoritetaan äärettömän monta kertaa.

Ikuinen toisto ei yleensä ole se mitä halutaan. Toisto voidaan keskeyttää esim. komennolla break.

while ( true ) {
    System.out.println("osaan ohjelmoida!");

    System.out.print("jatketaanko (ei lopettaa)? ");
    String komento = lukija.nextLine();
    if ( komento.equals("ei") ) {
        break;
    }
}

System.out.println("kiitos ja kuulemiin.");

Nyt toisto etenee siten että ensin tulostuu osaan ohjelmoida! ja tämän jälkeen ohjelma kysyy käyttäjältä jatketaanko vielä. Jos käyttäjä vastaa ei, suoritetaan komento break jonka ansiosta toisto lopetetaan ja suoritetaan komento joka tulostaa kiitos ja kuulemiin.

osaan ohjelmoida!
jatketaanko (ei lopettaa)? joo
osaan ohjelmoida!
jatketaanko (ei lopettaa)? jawohl
osaan ohjelmoida!
jatketaanko (ei lopettaa)? ei
kiitos ja kuulemiin.

Toiston sisällä voi tehdä erilaisia asioita. Seuraavassa yksinkertainen laskin. Laskin kysyy käyttäjältä komentoa. Komennossa lopetus suoritetaan break ja toisto loppuu. Tämän jälkeen kysytään kahta lukua. Jos komento oli summa lasketaan lukujen summa ja tulostetaan se. Jos komento oli erotus toimitaan vastaavasti. Muussa tapauksessa ilmoitetaan että komento on tuntematon.

System.out.println("tervetuloa käyttämään laskinta");

while ( true ) {    
    System.out.print("anna komento (summa, erotus, lopetus): ");
    String komento = lukija.nextLine();
    if ( komento.equals("lopetus") ) {
        break;
    }

    System.out.print("anna luvut ");
    int eka = Integer.parseInt(lukija.nextLine());
    int toka = Integer.parseInt(lukija.nextLine());

    if ( komento.equals("summa") ) {     
        int summa = eka+toka;
        System.out.println( "lukujen summa " + summa );
    } else if ( komento.equals("erotus") ) {     
        int erotus = eka-toka;
        System.out.println( "lukujen erotus " + erotus );
    } else {     
        System.out.println( "tuntematon komento" );
    } 

}
System.out.println("kiitos ja kuulemiin.");

Screencast joka näyttää miten ohjelma syntyy:

Anna salasana: nauris
Väärin!
Anna salasana: lanttu
Väärin!
Anna salasana: porkkana
Oikein!

Salaisuus on: znvavbfgv grugl!

Anna salasana: nauris
Väärin!

Anna salasana: porkkana
Oikein!

Anna salasana: bataatti
Väärin!

Anna salasana: nauris
Väärin!
Anna salasana: lanttu
Väärin!
Anna salasana: porkkana
Oikein!

Anna salasana: nauris
Väärin!
Anna salasana: lanttu
Väärin!
Anna salasana: porkkana
Oikein!

Salaisuus on: znvavbfgv grugl!

Kuvaaja.lisaaNumero(13.0);

public static void main(String[] args) throws Exception {
    Scanner lukija = new Scanner(System.in);

    System.out.println("NHL-tilastopalvelu");
    while ( true ) {
        System.out.println("");
        System.out.print("komento (pisteet, maalit, syotot, jaahyt, pelaaja, joukkue, lopeta): ");
        String komento = lukija.nextLine();

        if ( komento.equals("lopeta")) {
            break;
        }

        if ( komento.equals("pisteet")) {
            // tulosta 10 parasta pisteiden tekijää    
        } else if ( komento.equals("maalit")) {
            // tulosta 10 parasta maalintekijää     
        } else if ( komento.equals("syotot")) {
            // tulosta 10 parasta syöttäjää      
        } else if ( komento.equals("jaahyt")) {
            // tulosta 10 eniten jäähyjä saanutta    
        } else if ( komento.equals("pelaaja")) {
            // kysy käyttäjältä kenen tiedot halutaan tulostaa ja tulosta ne     
        } else if ( komento.equals("joukkue")) {
            // kysy käyttäjältä minkä joukkueen tilastot halutaan ja tulosta ne 
            // huom: tulostus tulee tapahtua pisteidentekojärjestyksessä (eli eniten pisteitä tehneet ensin) 
        }
    }
}

NHL-tilastopalvelu

komento (pisteet, maalit, syotot, jaahyt, pelaaja, joukkue): syotot
Henrik Sedin           VAN        43 11 + 38= 49  36
Erik Karlsson          OTT        43  6 + 35= 41  24
Claude Giroux          PHI        36 18 + 30= 48  16
Pavel Datsyuk          DET        41 13 + 30= 43  10
Brian Campbell         FLA        42  3 + 30= 33   4
Daniel Sedin           VAN        42 18 + 29= 47  32
Jason Pominville       BUF        41 14 + 29= 43   8
Nicklas Backstrom      WSH        38 13 + 29= 42  22
Joffrey Lupul          TOR        41 19 + 28= 47  36
Evgeni Malkin          PIT        33 16 + 28= 44  30

komento (pisteet, maalit, syotot, jaahyt, pelaaja, joukkue): pelaaja
kuka pelaaja: Jokinen
Olli Jokinen           CGY        43 12 + 21= 33  32
Jussi Jokinen          CAR        40  4 + 19= 23  30

komento (pisteet, maalit, syotot, jaahyt, pelaaja, joukkue): joukkue
mikä joukkue: DET
Pavel Datsyuk          DET        41 13 + 30= 43  10
Johan Franzen          DET        41 16 + 20= 36  34
Valtteri Filppula      DET        40 14 + 21= 35  10
Henrik Zetterberg      DET        41  8 + 24= 32  14
// lisää pelaajien nimiö

komento (pisteet, maalit, syotot, jaahyt, pelaaja, joukkue): lopeta

9. Muuttuvat muuttujat

Olemassaolevan muuttujan arvoa halutaan usein muuttaa. Tämä onnistuu tavallisen sijoituslausekkeen avulla. Seuraavassa muuttujan ika arvoa kasvatetaan yhdellä:

int ika = 1;

System.out.println( ika );    // tulostuu 1
ika = ika + 1;                // ika:n uusi arvo on ika:n vanha arvo plus yksi    
System.out.println( ika );    // tulostuu 2

Komento ika = ika + 1 siis kasvattaa muuttujan ika arvoa yhdellä. Muuttujan arvon kasvattaminen yhdellä onnistuu myös seuraavasti:

int ika = 1;

System.out.println( ika );    // tulostuu 1
ika++;                        // tarkoittaa samaa kuin ika = ika + 1;
System.out.println( ika );    // tulostuu 2

Toinen esimerkki:

int pituus = 100;

System.out.println( pituus );   // tulostuu 100
pituus = pituus - 50;    
System.out.println( pituus );   // tulostuu 50
pituus = pituus * 2;
System.out.println( pituus );   // tulostuu 100 
pituus = pituus / 4;
System.out.println( pituus );   // tulostuu 25
pituus--;                       // sama kuin pituus = pituus-1;
System.out.println( pituus );   // tulostuu 24

Scanner lukija = new Scanner(System.in);
int summa = 0;
int luettu;

// KIRJOITA OHJELMA TÄHÄN
// ÄLÄ KÄYTÄ MUITA MUUTTUJIA KUIN lukija, summa JA luettu!

System.out.println("Summa: "+summa);

Anna ensimmäinen luku: 3
Anna toinen luku: 6
Anna kolmas luku: 12

Summa: 21

Scanner lukija = new Scanner(System.in);

int summa = 0;
System.out.print("Anna lukuja, nolla lopettaa: ");
while (true) {
    int luettu = Integer.parseInt(lukija.nextLine());
    if (luettu == 0) {
        break;
    }

    // TEE JOTAIN TÄÄLLÄ

    System.out.println("Summa nyt: "+summa);
}
System.out.println("Summa lopussa: "+summa);

Anna lukuja, nolla lopettaa:
3
Summa nyt: 3
2
Summa nyt: 5
1
Summa nyt: 6
1
Summa nyt: 7
0
Summa lopussa: 7

10. Lisää toistoa

Opimme aiemmin toteuttamaan while(true)-komennon avulla ohjelman, joka toistaa tiettyä komentosarjaa komennon break suorittamiseen asti.

Komento break ei ole ainoa tapa lopettaa toistoa. Toistokomennon yleinen muoto on while (ehto), jossa ehtona voi olla mikä tahansa totuusarvoinen lauseke, eli ehto voi olla täsmälleen samaa muotoa kuin if-komentojen ehdot.

Seuraavassa esimerkissä tulostetaan luvut 1, 2, ..., 10. Kun luku-muuttuja saa arvokseen yli 10, while-ehto ei ole enää voimassa ja toistaminen lopetetaan.

int luku = 1;

while (luku < 11) {
    System.out.println(luku);
    luku++;    // luku++ tarkoittaa samaa kuin luku = luku + 1
}

Lue ylläoleva "niin pitkään kuin luku on pienempi kuin 11, tulosta luku ja kasvata lukua yhdellä".

Ylläolevassa koodissa ehdossa olevaa muuttujaa luku kasvatettiin jokaisella kierroksella yhdellä. Päivitys voi olla mikä tahansa, eli ehdossa olevan muuttujan ei tarvitse suinkaan aina kasvaa yhdellä, esim:

int luku = 1024;

while (luku >= 1) {
    System.out.println(luku);
    luku = luku / 2;
}

Screencast aiheesta:

1
2
3
(välissä paljon rivejä)
98
99
100

100
99
98
(välissä paljon rivejä)
3
2
1

2
4
6
(välissä paljon rivejä)
96
98
100

Mihin asti? 3
1
2
3

Mihin asti? 5
1
2
3
4
5

Ensimmäinen: 5
Viimeinen: 8
5
6
7
8

Ensimmäinen: 16
Viimeinen: 12

10.1 Sijoitusoperaatiot

Koska vanhan muuttujan arvon muuttaminen on hyvin yleinen operaatio, on Javassa sitä varten erityiset sijoitusoperaatiot.

int pituus = 100;

pituus += 10;  // sama kuin pituus = pituus + 10;
pituus -= 50;  // sama kuin pituus = pituus - 50;

Olemassaolevan muuttujan arvoa muuttava sijoitusoperaatio merkitään muuttuja muutostyyppi= muutos, esimerkiksi muuttuja += 5. Huomaa, että muuttujan tyyppi pitää aina kertoa ennen kuin sille voidaan asettaa arvo. Muuttuja tulee siis aina esitellä ennen kuin se on käytettävissä. Muuttujan esittely tapahtuu kertomalla muuttujan tyyppi ja nimi.

Seuraava esimerkki ei toimi, sillä muuttujan pituus tyyppiä ei ole kerrottu.

pituus = pituus + 100;   // ei toimi!
pituus += 100;           // ei toimi!

Kun tyyppi on kerrottu, laskutkin toimivat oikein.

int pituus = 0;
pituus = pituus + 100;
pituus += 100;

// muuttujan pituus arvo on 200

Myös muille kuin yhteen- ja vähennyslaskuille on Javassa vastaavat sijoitusoperaatiot.

int pituus = 100;

pituus *= 10; // sama kuin pituus = 10 * pituus; 
pituus /= 100; //sama kuin pituus = pituus / 100;
pituus %= 3;  // sama kuin pituus = pituus % 3;

// muuttujan pituus arvo 1

Usein ohjelmissa esiintyy toisto jonka aikana muuttujaan lasketaan jokin toistosta riippuvainen arvo. Seuraava ohjelma laskee tulon 4*3 hieman kömpelöllä tavalla eli summana 3+3+3+3:

int tulos = 0;

int i = 0;
while ( i < 4 ) {
    tulos = tulos + 3;
    i++;   // tarkoittaa samaa kuin i = i+1;
}

Alussa tulos = 0. Toistossa muuttujan arvo nousee joka kierroksella 3:lla. Ja koska toistoja on 4, on lopulta muuttujan arvona siis 3*4.

Käyttämällä yllä esiteltyä sijoitusoperaattoria, sama saadaan aikaan seuraavasti:

int tulos = 0;

int i = 0;
while ( i < 4 ) {
    tulos += 3;      // tämä on siis sama kuin tulos = tulos + 3;
    i++;             // tarkoittaa samaa kuin i = i+1;
}

Mihin asti? 3
Summa on 6   

Mihin asti? 7
Summa on 28   

Ensimmäinen: 3
Viimeinen: 5
Summa on 12

Ensimmäinen: 2
Viimeinen: 8
Summa on 35

Anna luku: 3
Kertoma on 6

Anna luku: 10
Kertoma on 3628800

Anna luku: 3
Tulos on 15

Anna luku: 7
Tulos on 255

10.2 Ikuinen silmukka

Yksi suosituimmista ohjelmointivirheistä toistolauseissa on tehdä vahingossa ikuinen silmukka. Seuraavassa yritetään tulostaa ruudulle 10 kertaa "En enää ikinä ohjelmoi ikuista silmukkaa":

int i = 0;

while( i<10 ) {
    System.out.println("En enää ikinä ohjelmoi ikuista silmukkaa");
}

Toistokertojen määrää kontrolloiva muuttuja i on aluksi 0 ja toistoja on tarkoitus tehdä niin kauan kuin i<10. Käy kuitenkin hieman hassusti: muuttujan i arvoa ei muuteta missään, joten toistoehto pysyy ikuisesti totena.

10.3 while ja lopetus

Olemme tehneet peräkkäin jo muutamia toistotehtäviä, joissa toistoehto on suunnilleen muotoa:

int i = 1;
while ( i < 10 ) {
    // ...
    i++;
}

Ylläolevassa rungossa muuttuja i muistaa toistokertojen määrän, ja lopetusehto perustuu i:n vertailuun.

Muistellaan taas toiston lopetusta. Toiston lopetuksen ei tarvitse perustua toistokertojen laskemiseen. Katsotaan esimerkkiä jossa kysytään käyttäjän ikää. Jos ikä ei ole välillä 5-85, annetaan huomautus ja kysytään ikä uudelleen. Toistolauseen while-lauseen ehto voi siis olla mitä tahansa totuusarvon tuottavaa.

System.out.println("ikäsi: ");

int ika = Integer.parseInt(lukija.nextLine());

while( ika < 5 || ika  > 85 ) {   // ikä pienempi kuin 5 TAI suurempi kuin 85
    System.out.println("Valehtelet");
    if ( ika < 5 ) {
        System.out.println("Olet niin nuori ettet osaa kirjoittaa");   
    } else if ( ika > 85 ) {
        System.out.println("Olet niin vanha ettet osaa käyttää tietokonetta");   
    } 

    System.out.println("syötä ikäsi uudelleen: ");
    ika = Integer.parseInt(lukija.nextLine();
}

System.out.println("Ikäsi on siis "+ ika);

Ohjelman olisi voinut tehdä myös vanhaa tuttua while(true) -rakennetta käyttäen:

System.out.println("ikäsi: ");

while( true ) {   
    int ika = Integer.parseInt(lukija.nextLine());

    if ( ika >= 5 && ika <= 85 ) {   // ikä 5:n JA 85:n välillä
        break;                              // lopetetaan toisto
    }

    System.out.println("Valehtelet");
    if ( ika < 5 ) {
        System.out.println("Olet niin nuori ettet osaa kirjoittaa");   
    } else {  // ikä siis yli 85
        System.out.println("Olet niin vanha ettet osaa käyttää tietokonetta");   
    } 

    System.out.println("syötä ikäsi uudelleen: ");
}

System.out.println("Ikäsi on siis "+ ika);

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3
Keskiarvo: 3.666666666666

Syötä luvut:
5
2
4
-1
Kiitos ja näkemiin!
Summa: 11
Lukuja: 3
Keskiarvo: 3.666666666666
Parillisia: 2
Parittomia: 1

int i = 0;
while ( i < 10 ) {
    System.out.println( i );
    i++;
}

for ( int i = 0; i < 10 ; i ++ ) {
    System.out.println( i );
}

11. Metodit

Olemme käyttäneet useita erilaisia komentoja Javassa: sijoitusta, laskutoimituksia, vertailuja, if:iä ja whileä. Ruudulle tulostaminen on tehty "komentoa" System.out.println() käyttäen. Kahden luvun maksimi osataan laskea "komennolla" Math.max(). Tuttuja ovat myös lukija.nextLine() ja sen kanssa usein nähty Integer.parseInt().

Huomaamme, että jälkimmäinen joukko edellä lueteltuja komentoja poikkeaa if:istä ja while:stä ym. siinä, että komennon perässä on sulut ja joskus sulkujen sisällä komennolle annettava syöte. "Sulkuihin päättyvät" eivät oikeastaan olekaan komentoja vaan metodeja.

Teknisesti ottaen metodi tarkoittaa koodinpätkää, jota voi kutsua muualta ohjelmakoodista. Koodirivi System.out.println("olen metodille annettava parametri!") siis tarkoittaa, että kutsutaan metodia, joka suorittaa ruudulle tulostamisen. Metodin suorituksen jälkeen palataan siihen kohtaa missä ennen metodikutsua oltiin menossa. Metodille suluissa annettua syötettä kutsutaan metodin parametriksi.

Parametrin lisäksi metodilla voi olla paluuarvo. Esim. tuttu koodinpätkä:

int luku = Integer.parseInt( lukija.nextLine() );

sisältää kaksi metodikutsua. Ensin kutsutaan sisempänä olevaa metodia lukija.nextLine. Metodilla on paluuarvonaan käyttäjän syöttämä merkkijono. Seuraavaksi kutsutaan metodia Integer.parseInt. Metodikutsun parametrina on merkkijono jonka lukija.nextLine:n kutsu palautti ja metodin paluuarvona on merkkijonoa vastaava kokonaisluku.

Metodin nimeen näyttää liittyvän piste, esim. lukija.nextLine(). Oikeastaan tässä metodin nimi onkin pisteen oikeanpuoleinen osa, eli nextLine(). Pisteen vasemmanpuoleinen osa, eli tässä lukija kertoo kenen metodista on kyse. Eli kyseessä on lukijan metodi nextLine. Opimme hiukan myöhemmin tarkemmin mistä tässä pisteen vasemmanpuoleisessa osassa on kyse. Tarkka lukija tietysti huomaa, että System.out.println():ssa on "kaksi pistettä". Metodin nimi tässä on println, ja System.out on se kenen metodista on kyse. Karkeasti ottaen System.out tarkoittaa koneen näyttöä.

Tähän mennessä käyttämämme metodit ovat kaikki olleet Javan valmiita metodeita. Nyt opettelemme tekemään omia metodeita.

12. Omat metodit

Olemme tähän mennessä ohjelmoineet ohjelmamme siten, että kaikki tapahtuu yhdessä jatkumossa ja koodia luetaan ylhäältä alas.

Edellä mainittiin että "metodi tarkoittaa koodinpätkää, jota voi kutsua muualta ohjelmakoodista". Javan valmiita metodeja on käytetty jo oikeastaan ensimmäisestä ohjelmasta lähtien.

Javan valmiiden metodien käytön lisäksi ohjelmoija voi kirjoittaa itse metodeja joita sovellus kutsuu. Oikeastaan on hyvin poikkeuksellista jos ohjelmassa ei ole yhtään itse kirjoitettua metodia. Tästälähtien lähes jokainen kurssilla tehty ohjelma sisältääkin itsekirjoitettuja metodeja.

Ohjelmarunkoon metodit kirjoitetaan main:in aaltosulkeiden ulkopuolelle mutta kuitenkin "uloimmaisten" aaltosulkeiden sisäpuolelle, joko mainin ylä- tai alapuolelle

import java.util.Scanner;

public class OhjelmaRunko {
    // omia metodeja tänne

    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omia metodeja tai tänne
}

Luodaan metodi tervehdi.

public static void tervehdi() {
    System.out.println("Terveiset metodimaailmasta!");
}

Ja asetetaan se metodeille kuuluvalle paikalle.

import java.util.Scanner;

public class OhjelmaRunko {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);
        // ohjelmakoodi
    }

    // omat metodit
    public static void tervehdi() {
        System.out.println("Terveiset metodimaailmasta!");
    }
}

Metodin määrittely sisältää kaksi osaa. Metodimäärittelyn ensimmäisellä rivillä on metodin nimi eli tervehdi. Nimen vasemmalla puolella tässä vaiheessa määreet public static void. Metodin nimen sisältävän rivin alla on aaltosulkeilla erotettu koodilohko, jonka sisälle kirjoitetaan metodin koodi, eli ne komennot jotka metodia kutsuttaessa suoritetaan. Metodimme tervehdi ei tee muuta kuin kirjoittaa rivillisen tekstiä ruudulle.

Itsekirjoitetun metodin kutsu on helppoa, kirjoitetaan metodin nimi ja perään sulut ja puolipiste. Seuraavassa main eli pääohjelma kutsuu metodia ensin kerran ja sen jälkeen useita kertoja.

import java.util.Scanner;

public class OhjelmaRunko {
    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in);

        // ohjelmakoodi
        System.out.println("Kokeillaan pääsemmekö metodimaailmaan:");
        tervehdi();

        System.out.println("Näyttää siltä, kokeillaan vielä:");
        tervehdi(); 
        tervehdi(); 
        tervehdi();
    }

    // omat metodit
    public static void tervehdi() {
        System.out.println("Terveiset metodimaailmasta!");
    }
}

Ohjelman suoritus saa aikaan seuraavan tulosteen:

Kokeillaan pääsemmekö metodimaailmaan:
Terveiset metodimaailmasta!
Näyttää siltä, kokeillaan vielä:
Terveiset metodimaailmasta!
Terveiset metodimaailmasta!
Terveiset metodimaailmasta!

Huomionarvoista tässä on koodin suoritusjärjestys. Koodin suoritus etenee siten, että pääohjelman -- eli main:in -- rivit suoritetaan ylhäältä alas yksi kerrallaan. Koodirivin ollessa metodikutsu, mennään suorittamaan metodin koodirivit, jonka jälkeen palataan josta metodin kutsu tapahtui. Tarkemmin ottaen metodikutsun jälkeiselle riville.

Jos ollaan tarkkoja on pääohjelma eli main itsekin metodi. Kun ohjelma käynnistyy, kutsuu käyttöjärjestelmä main:ia. Metodi main on siis ohjelman käynnistyspiste, jonka ylimmältä riviltä ohjelman suoritus lähtee liikkeelle. Ohjelman suoritus loppuu kun päädytään mainin loppuun.

Jatkossa kun esittelemme metodeja, emme erikseen mainitse että niiden täytyy sijaita omalla paikallaan. Metodia ei esimerkiksi voi määritellä toisen metodin sisällä.

public static void main(String[] args) {
    tulostaTeksti();
}

public static void tulostaTeksti() {
    // kirjoita koodia tähän
}

Alussa olivat suo, kuokka ja Java.

public static void main(String[] args) {
    // kysy käyttäjältä, montako kertaa teksti tulostetaan
    // kutsu metodia tulostaTeksti while-komennon avulla useita kertoja
}

public static void tulostaTeksti() {
    // kirjoita koodia tähän
}

Kuinka monta?
7
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.
Alussa olivat suo, kuokka ja Java.

12.1 Metodin parametrit

Metodista saa huomattavasti monikäyttöisemmän antamalla sille parametreja. Parametrit ovat muuttujia, jotka määritellään metodin ylimmällä rivillä metodin nimen jälkeen olevien sulkujen sisällä. Kun metodia kutsutaan, sen parametreille annetaan arvot kutsuvaiheessa.

Seuraavassa esimerkissä määritellään parametrillinen metodi tervehdi, jolla on String-tyyppinen parametri nimi.

public static void tervehdi(String nimi) {
    System.out.println("Hei " + nimi + ", terveiset metodimaailmasta!");
}

Kutsutaan metodia tervehdi siten, että parametrin nimi arvoksi asetetaan ensimmäisellä kutsulla Matti ja toisella kutsulla Arto.

public static void main(String[] args) {
    tervehdi("Matti");
    tervehdi("Arto");
}

Hei Matti, terveiset metodimaailmasta!
Hei Arto, terveiset metodimaailmasta!

Aivan kuten kutsuttaessa Javan valmista System.out.println()-metodia, voi oman metodin kutsussa parametrina käyttää monimutkaisempaa ilmausta:

public static void main(String[] args) {
    String nimi1 = "Antti";
    String nimi2 = "Mikkola";
    tervehdi( nimi1 + " " + nimi2 );

    int ika = 24;
    tervehdi("Juhana " + ika + " vuotta");
}

Hei Antti Mikkola, terveiset metodimaailmasta!
Hei Juhana 24 vuotta, terveiset metodimaailmasta!

Molemmissa tapauksissa metodilla on edelleen vain 1 parametri. Parametrin arvo lasketaan ennen metodin kutsumista. Ensimmäisessä tapauksessa parametrin arvo saadaan merkkijonokatenaationa nimi1 + " " + nimi2 joka siis on arvoltaan Antti Mikkola ja jälkimmäisessä tapauksessa merkkijonokatenaatiosta "Juhana " + ika + " vuotta".

12.2 Monta parametria

Metodille voidaan määritellä useita parametreja. Tällöin metodin kutsussa parametrit annetaan samassa järjestyksessä.

public static void tervehdi(String nimi, String mistaTerveiset) {
    System.out.println("Hei " + nimi + ", terveiset " + mistaTerveiset);
}

String kuka = "Matti";
String terveiset = "Kyröjoelta";

tervehdi(kuka, terveiset);
tervehdi(kuka, terveiset + " ja Kumpulasta");

Jälkimmäisessä tervehdi-funktion kutsussa toinen parametri muodostetaan katenoimalla muuttujaan terveiset teksti " ja Kumpulasta". Tämä suoritetaan ennen varsinaista funktion suoritusta.

Hei Matti, terveiset Kyröjoelta
Hei Matti, terveiset Kyröjoelta ja Kumpulasta  

12.3 Metodi kutsuu toista metodia

main ei ole suinkaan ainoa joka voi kutsua metodeita. Metodit voivat kutsua myös toisiaan. Tehdään metodi tervehdiMontaKertaa, joka tervehtii käyttäjää useasti metodin tervehdi avulla:

public static void tervehdi(String nimi) {
    System.out.println("Hei " + nimi + ", terveiset metodimaailmasta!");
}

public static void tervehdiMontaKertaa(String nimi, int kerrat) {
    int i = 0;
    while ( i < kerrat ) {
        tervehdi(nimi);
        i++;
    }

}

public static void main(String[] args) {
    tervehdiMontaKertaa("Antti", 3);
    System.out.println("ja");
    tervehdiMontaKertaa("Martin", 2);
}

Tulostuu:

Hei Antti, terveiset metodimaailmasta!
Hei Antti, terveiset metodimaailmasta!
Hei Antti, terveiset metodimaailmasta!
ja
Hei Martin, terveiset metodimaailmasta!
Hei Martin, terveiset metodimaailmasta!

Screencast aiheesta:

private static void tulostaTahtia(int maara) {
    // yhden tähden saat tulostettua komennolla
    // System.out.print("*");
    // kutsu tulostuskomentoa n kertaa
    // tulosta lopuksi rivinvaihto komennolla
    // System.out.println("");
}

public static void main(String[] args) {
    tulostaTahtia(5);
    tulostaTahtia(3);
    tulostaTahtia(9);
}

*****
***
*********

****
****
****
****

*****************
*****************
*****************

*
**
***
****

   *
  **
 ***
****

   *
  ***
 *****
*******
  ***
  ***

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
        ***
        ***

Arvaa luku: 73
Luku on pienempi, tehtyjä arvauksia: 1
Arvaa luku: 22
Luku on suurempi, tehtyjä arvauksia: 2
Arvaa luku: 51
Luku on suurempi, tehtyjä arvauksia: 3
Arvaa luku: 62
Luku on suurempi, tehtyjä arvauksia: 4
Arvaa luku: 68
Luku on suurempi, tehtyjä arvauksia: 5
Arvaa luku: 71
Luku on pienempi, tehtyjä arvauksia: 6
Arvaa luku: 70
Onneksi olkoon, oikein arvattu!

Arvaa luku: 12
Luku on suurempi

Arvaa luku: 66
Luku on pienempi

Arvaa luku: 42
Onneksi olkoon, oikein arvattu!

Arvaa luku: 55
Luku on suurempi
Arvaa luku: 85
Luku on pienempi
Arvaa luku: 77
Luku on suurempi
Arvaa luku: 81
Luku on suurempi
Arvaa luku: 83
Onneksi olkoon, oikein arvattu!

Arvaa luku: 55
Luku on suurempi, tehtyjä arvauksia: 1
Arvaa luku: 85
Luku on pienempi, tehtyjä arvauksia: 2
Arvaa luku: 77
Luku on suurempi, tehtyjä arvauksia: 3
Arvaa luku: 81
Luku on suurempi, tehtyjä arvauksia: 4
Arvaa luku: 83
Onneksi olkoon, oikein arvattu!

Scanner lukija = new Scanner(System.in);
Hirsipuu hirsipuu = new Hirsipuu();

System.out.println("************");
System.out.println("* HIRSIPUU *");
System.out.println("************");
System.out.println("");
tulostaValikko();
System.out.println("");

// OHJELMOI TOTEUTUKSESI TÄNNE

System.out.println("Kiitos pelistä!");

public static void tulostaValikko() {
    System.out.println(" * valikko *");
    System.out.println("lopeta   - lopettaa pelin");
    System.out.println("tilanne  - tulostaa tarkemman tilanteen");
    System.out.println("yksittäinen kirjain arvaa annettua kirjainta");
    System.out.println("tyhjä rivi tulostaa tämän valikon");
}

while (hirsipuu.peliKaynnissa()) {
  String komento = lukija.nextLine();
  // ...
}

************
* HIRSIPUU *
************

* valikko *
lopeta   - lopettaa pelin
tilanne  - tulostaa tarkemman tilanteen
yksittäinen kirjain arvaa annettua kirjainta
tyhjä rivi tulostaa tämän valikon 

Anna komento: 
ei lopeta

Anna komento: 
lopeta
Kiitos pelistä!

************
* HIRSIPUU *
************

* valikko *
lopeta   - lopettaa pelin
tilanne  - tulostaa tarkemman tilanteen
yksittäinen kirjain arvaa annettua kirjainta
tyhjä rivi tulostaa tämän valikon

Anna komento: 
tilanne
Et ole vielä tehnyt yhtään arvausta.
Käyttämättömät kirjaimet: abcdefghijklmnopqrstuvwxyzåäö

Anna komento: 
lopeta
Kiitos pelistä!

String komento = lukija.nextLine();

if(komento.length() == 1) {  // komento on vain yksi kirjain, eli kyseessä on arvaus
    hirsipuu.arvaa(komento);
} 

...
Anna komento: 
a
Kirjainta a ei löytynyt sanasta.

Anna komento: 
b
Kirjainta b ei löytynyt sanasta.

Anna komento: 
c
Kirjain c löytyi sanasta!

Anna komento: 
lopeta
Kiitos pelistä!

String nalle = "puh";
if(nalle.isEmpty()) {
    System.out.println("Tyhjä merkkijono");
} else {
    System.out.println("Löytyipäs sieltä jotain!");
}

...
Anna komento: 
a
Kirjainta a ei löytynyt sanasta.
____
|   
|   
|   
|   
/|\
Arvattava sana: ????

Anna komento: 
m
Kirjain m löytyi sanasta!
____
|   
|   
|   
|   
/|\
Arvattava sana: m???

Anna komento: 
lopeta
Kiitos pelistä!

13. Lisää metodeista

Edellisellä viikolla opettelimme kirjoittamaan omia metodeja. Metodien avulla voimme jäsennellä ohjelmaa pienemmiksi hyvin nimetyiksi. selkeän tehtävän omaaviksi loogisiksi kokonaisuuksiksi. Tämä sekä helpottaa ongelmanratkaisua että parantaa ohjelman luettavuutta niin ohjelmoijan kuin ohjelmaa myöhemmin mahdollisesti ylläpitävänkin osalta. Tästä lähtien oikeastaan jokainen tekemämme ohjelma sisältää metodeita.

Jatketaan edelleen metodien parissa.

13.1 Metodit ja muuttujien näkyvyys

Yritetään muuttaa metodin sisältä pääohjelman muuttujan arvoa.

// pääohjelma
public static void main(String[] args) {
    int luku = 1;
    kasvataKolmella();
}

// metodi
public static void kasvataKolmella() {
    luku = luku + 3;
}

Ohjelma ei kuitenkaan toimi, sillä metodi ei näe pääohjelman muuttujaa luku.

Yleisemminkin voi todeta, että pääohjelman muuttujat eivät näy metodien sisään, ja metodin muuttujat eivät näy muille metodeille tai pääohjelmalle. Ainoa keino viedä metodille tietoa ulkopuolelta on parametrin avulla.

// pääohjelma
public static void main(String[] args) {
    int luku = 1;
    System.out.println("Pääohjelman muuttujan luku arvo: " + luku);
    kasvataKolmella(luku);
    System.out.println("Pääohjelman muuttujan luku arvo: " + luku);
}

// metodi
public static void kasvataKolmella(int luku) {
    System.out.println("Metodin parametrin luku arvo: " + luku);
    luku = luku + 3;
    System.out.println("Metodin parametrin luku arvo: " + luku);
}

Yllä metodilla kasvataKolmella on parametri luku. Parametri luku kopioidaan metodin käyttöön. Kun yllä oleva ohjelma suoritetaan, nähdään seuraavanlainen tulostus.

Pääohjelman muuttujan luku arvo: 1
Metodin parametrin luku arvo: 1
Metodin parametrin luku arvo: 4
Pääohjelman muuttujan luku arvo: 1

Parametrina annettu luku siis kopioitiin metodin käyttöön. Jotta saisimme luvun uuden arvon myös pääohjelmaan, tulee metodin palauttaa arvo.

13.2 Metodin paluuarvot

Metodi voi palauttaa arvon. Tähän mennessä kurssilla olleissa esimerkeissä ja tehtävissä metodit eivät palauttaneet mitään. Tämä on merkitty kirjoittamalla metodin ylimmälle riville heti nimen vasemmalle puolelle void.

public static void kasvataKolmella() {
...

Arvon palauttavaa metodia määriteltäessä täytyy määritellä myös palautettavan arvon tyyppi. Paluuarvon tyyppi merkitään metodin nimen vasemmalle puolelle. Seuraavassa metodi joka palauttaa aina kokonaisluvun 10, metodin tyyppi on int. Palautus tapahtuu komennolla return:

public static int palautetaanAinaKymppi() {
    return 10;
}

Jotta metodin palauttamaa arvoa voisi käyttää, tulee paluuarvo ottaa talteen muuttujaan:

public static void main(String[] args) {
    int luku = palautetaanAinaKymppi();

    System.out.println( "metodi palautti luvun " + luku );
}

Metodin paluuarvo sijoitetaan int-tyyppiseen muuttujaan aivan kuin mikä tahansa muukin int-arvo. Paluuarvo voi toimia myös osana mitä tahansa lauseketta:

double luku = 4 * palautetaanAinaKymppi() + (palautetaanAinaKymppi() / 2) - 8;

System.out.println( "laskutoimituksen tulos " + luku );

Kaikki muuttujatyypit, mitä olemme tähän mennessä nähneet, voidaan palauttaa metodista:

public static void metodiJokaEiPalautaMitaan() {
    // metodin runko
}

public static int metodiJokaPalauttaaKokonaisLuvun() {
    // metodin runko, tarvitsee return-komennon
}

public static String metodiJokaPalauttaaTekstin() {
    // metodin runko, tarvitsee return-komennon
}

public static double metodiJokaPalauttaaLiukuluvun() {
    // metodin runko, tarvitsee return-komennon
}

Jos metodille määritellään paluuarvo, on sen myös pakko palauttaa arvo, esimerkiksi seuraava metodi on virheellinen.

public static String virheellinenMetodi() {
    System.out.println("Väitän palauttavani merkkijonon, mutten palauta sitä.");
}

Seuraavassa esimerkissä määritellään metodi summan laskemiseen. Tämän jälkeen metodia käytetään laskemaan luvut 2 ja 7 yhteen. Metodikutsusta saatava paluuarvo asetetaan muuttujaan lukujenSumma.

public static int summa(int eka, int toka) {
    return eka + toka;
}

Metodin kutsu:

int lukujenSumma = summa(2, 7);
// lukujenSumma on nyt 9

Laajennetaan edellistä esimerkkiä siten, että käyttäjä syöttää luvut.

public static void main(String[] args) {
    Scanner lukija = new Scanner(System.in);

    System.out.print("Anna ensimmäinen luku: ");
    int eka = Integer.parseInt( lukija.nextLine() );

    System.out.print("Anna toinen luku: ");
    int toka = Integer.parseInt( lukija.nextLine() );

    System.out.print("Luvut ovat yhteensä: " + summa(eka,toka) );
}

public static int summa(int eka, int toka) {
    return eka + toka;
}

Kuten huomataan, metodin paluuarvoa ei tarvitse välttämättä sijoittaa muuttujaan, se voi olla osana tulostuslausetta aivan kuten mikä tahansa muukin int-arvo.

Huomaa, että metodin parametrien nimillä ja metodin kutsujan puolella määritellyillä muuttujan nimillä ei ole mitään tekemistä keskenään. Edellisessä esimerkissä sekä pääohjelman muuttujat että metodin parametrit olivat "sattumalta" nimetty samoin (eli eka ja toka). Seuraava toimisi aivan yhtä hyvin:

public static void main(String[] args) {
    Scanner lukija = new Scanner(System.in);

    System.out.print("Anna ensimmäinen luku: ");
    int luku1 = Integer.parseInt( lukija.nextLine() );

    System.out.print("Anna toinen luku: ");
    int luku2 = Integer.parseInt( lukija.nextLine() );

    System.out.print("Luvut ovat yhteensä: " + summa(luku1, luku2) );
}

public static int summa(int eka, int toka) {
    return eka + toka;
}

Nyt pääohjelman muuttujan luku1 arvo kopioituu metodin parametrin eka arvoksi ja pääohjelman muuttujan luku2 arvo kopioituu metodin parametrin toka arvoksi.

Seuraavassa esimerkissä metodia summa kutsutaan kokonaisluvuilla, jotka saadaan summa-metodin paluuarvoina.

int eka = 3;
int toka = 2;

int monenLuvunSumma = summa(summa(1, 2), summa(eka, toka));
// 1) suoritetaan sisemmät metodit:
//    summa(1, 2) = 3   ja summa(eka, toka) = 5
// 2) suoritetaan ulompi metodi:
//    summa(3, 5) = 8 
// 3) muuttujan monenLuvunSumma arvoksi siis tulee 8

13.3 Metodin omat muuttujat

Seuraava metodi laskee syötteinään saamiensa lukujen keskiarvon. Metodi käyttää apumuuttujia summa ja ka. Metodin sisäisen muuttujan määrittely tapahtuu tutulla tavalla.

public static double keskiarvo(int luku1, int luku2, int luku3) {

    int summa = luku1 + luku2 + luku3;
    double ka = summa / 3.0;

    return ka;
}

Metodin kutsu voi tapahtua esim seuraavasti

public static void main(String[] args) {
    Scanner lukija = new Scanner(System.in);

    System.out.print("Anna ensimmäinen luku: ");
    int eka = Integer.parseInt( lukija.nextLine() );

    System.out.print("Anna toinen luku: ");
    int toka = Integer.parseInt( lukija.nextLine() );

    System.out.print("ja kolmas luku: ");
    int kolmas = Integer.parseInt( lukija.nextLine() );

    double keskiarvonTulos = keskiarvo(eka, toka, kolmas);

    System.out.print("Lukujen keskiarvo: " + keskiarvonTulos );
}

Huomaa että metodin sisäiset muuttujat summa ja ka eivät näy pääohjelmaan. Yksi yleinen aloittelijan virhe olisikin yrittää käyttää metodia seuraavasi:

public static void main(String[] args) {
    // annetaan arvot muuttujille eka, toka ja kolmas

    keskiarvo(eka, toka, kolmas);

    // yritetään käyttää metodin sisäistä muuttujaa, EI TOIMI!
    System.out.print("Lukujen keskiarvo: " + ka );
}

Myös seuraavanlaista virhettä näkee usein:

public static void main(String[] args) {
    // annetaan arvot muuttujille eka, toka ja kolmas

    keskiarvo(eka, toka, kolmas);

    // yritetään käyttää pelkkää metodin nimeä, EI TOIMI!
    System.out.print("Lukujen keskiarvo: " + keskiarvo );
}

Eli tässä yritettiin käyttää pelkkää metodin nimeä muuttujamaisesti. Toimiva tapa metodin tuloksen sijoittamisen apumuuttujaan lisäksi on suorittaa metodikutsu suoraan tulostuslauseen sisällä:

public static void main(String[] args) {
    int eka = 3;
    int toka = 8;
    int kolmas = 4; 

    // kutsutaan metodia tulostuslauseessa, TOIMII!
    System.out.print("Lukujen keskiarvo: " + keskiarvo(eka, toka, kolmas) );
}

Tässä siis ensin tapahtuu metodikutsu joka palauttaa arvon 5.0 joka sitten tulostetaan tulostuskomennon avulla.

Screencast aiheesta:

public static int summa(int luku1, int luku2, int luku3, int luku4) {
    // kirjoita koodia tähän
    // muista että metodissa on oltava (lopussa) return!
}

public static void main(String[] args) {
    int vastaus = summa(4, 3, 6, 1);
    System.out.println("Summa: " + vastaus);
}

Summa: 14

public static int pienin(int luku1, int luku2) {
    // kirjoita koodia tähän
    // älä tulosta metodin sisällä mitään

    // lopussa oltava komento return
}

public static void main(String[] args) {
    int vastaus =  pienin(2, 7);
    System.out.println("Pienin: " + vastaus);
}

Pienin: 2

public static int suurin(int luku1, int luku2, int luku3) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    int vastaus =  suurin(2, 7, 3);
    System.out.println("Suurin: " + vastaus);
}

Suurin: 7

public static int summa(int luku1, int luku2, int luku3, int luku4) {
    // kopioi koodi tehtävästä 43
}

public static double keskiarvo(int luku1, int luku2, int luku3, int luku4) {
    // kirjoita koodia tähän
    // laske alkioiden summa kutsumalla metodia summa
}

public static void main(String[] args) {
    double vastaus = keskiarvo(4, 3, 6, 1);
    System.out.println("Keskiarvo: " + vastaus);
}

Keskiarvo: 3.5

14. Merkkijonot

Tässä luvussa tutustaan tarkemmin Javan merkkijonoihin, eli String:eihin. Olemme jo käyttäneet String-tyyppisiä muuttujia tulostuksen yhteydessä sekä oppineet vertailemaan merkkijonoja toisiinsa. Merkkijonoja vertailtiin toisiinsa kutsumalla merkkijonon equals()-metodia.

String elain = "Koira";

if( elain.equals("Koira") ) {
    System.out.println(elain + " sanoo vuh vuh");
} else if ( elain.equals("Kissa") ) {
    System.out.println(elain + " sanoo miau miau");
}

Merkkijonoilta voi kysyä niiden pituutta kirjoittamalla merkkijonon perään .length() eli kutsumalla merkkijonolle sen pituuden kertovaa metodia.

String banaani = "banaani";
String kurkku = "kurkku";
String yhdessa = banaani + kurkku;

System.out.println("Banaanin pituus on " + banaani.length());
System.out.println("Kurkku pituus on " + kurkku.length());
System.out.println("Sanan " + yhdessa + " pituus on " + yhdessa.length());

Edellä kutsutaan metodia length() kolmelle eri merkkijonolle. Kutsu banaani.length() kutsuu nimenomaan merkkijonon banaani pituuden kertovaa metodia, kun taas kurkku.length() on merkkijonon kurkku pituuden kertovan metodin kutsu, jne.Pisteen vasemman puoleinen osa kertoo kenen metodia kutsutaan.

Javassa on erillinen char-tietotyyppi kirjaimia varten. Yksittäiseen char-muuttujaan voi tallentaa yhden kirjaimen. Merkkijonolta voidaan kysyä sen kirjaimia kirjaimen paikan perusteella käyttämällä charAt()-metodia. Huomaa että laskeminen alkaa nollasta!

String kirja = "Kalavale";

char merkki = kirja.charAt(3);
System.out.println("Kirjan neljäs kirjain on " + merkki); //tulostaa "a"
  

Koska merkkijonon kirjaimet numeroidaan (eli teknisemmin ilmaistuna merkkijonoja indeksoidaan) alkaen paikasta 0, on merkkijonon viimeisen kirjaimen numero eli indeksi "merkkijonon pituus miinus yksi", eli kirja.charAt(kirja.length()-1). Esimerkiksi seuraava kaataa ohjelman: yritämme hakea kirjainta kohdasta jota ei ole olemassa.

char merkki = kirja.charAt(kirja.length());
  

Anna nimi: Pekka
Kirjainmäärä: 5

Anna nimi: Katariina
Kirjainmäärä: 9

Anna nimi: Pekka
Ensimmäinen kirjain: P

Anna nimi: Katariina
Ensimmäinen kirjain: K

Anna nimi: Pekka
Viimeinen kirjain: a

Anna nimi: Katariina
Viimeinen kirjain: a

Anna nimi: Pekka
1. kirjain: P
2. kirjain: e
3. kirjain: k

Anna nimi: me

Anna nimi: Pekka
1. kirjain: P
2. kirjain: e
3. kirjain: k
4. kirjain: k
5. kirjain: a

Anna nimi: Katariina
1. kirjain: K
2. kirjain: a
3. kirjain: t
4. kirjain: a
5. kirjain: r
6. kirjain: i
7. kirjain: i
8. kirjain: n
9. kirjain: a

Anna nimi: Pekka
Väärinpäin: akkeP

Anna nimi: Katariina
Väärinpäin: aniirataK

14.1 Muita merkkijonojen metodeja

Merkkijonosta halutaan usein lukea jokin tietty osa. Tämä onnistuu mekkkijonojen eli String-luokan metodilla substring. Sitä voidaan käyttää kahdella tavalla: yksiparametrisenä palauttamaan merkkijonon loppuosa tai kaksiparametrisena palauttamaan parametrien valitsema osajono merkkijonosta:

String kirja = "Kalavale";

System.out.println(kirja.substring(4)); //tulostaa "vale"
System.out.println(kirja.substring(2,6)); //tulostaa "lava"

Koska substring-metodin paluuarvo on String-tyyppinen, voidaan metodin paluuarvo ottaa talteen String-tyyppiseen muuttujaan kirja..

String kirja = "8 veljestä";

String loppuosa = kirja.substring(2);
System.out.println("7 " + loppuosa); // tulostaa: 7 veljestä

String-luokan metodit tarjoavat myös mahdollisuuden etsiä tekstistä tiettyä sanaa. Esimerkiksi sana "erkki" sisältyy tekstiin "merkki". Metodi indexOf() etsii parametrinaan annettua sanaa merkkijonosta. Jos sana löytyi, se palauttaa sanan ensimmäisen kirjaimen indeksin, eli paikan (muista että paikkanumerointi alkaa nollasta!). Jos taas sanaa ei löytynyt merkkijonosta palautetaan arvo -1.

String sana = "merkkijono";

int indeksi = sana.indexOf("erkki"); //indeksin arvoksi tulee 1
System.out.println(sana.substring(indeksi)); //tulostetaan "erkkijono"

indeksi = sana.indexOf("jono"); //indeksin arvoksi tulee 6
System.out.println(sana.substring(indeksi)); //tulostetaan "jono"

indeksi = sana.indexOf("kirja"); //sana "kirja" ei sisälly sanaan "merkkijono"
System.out.println(indeksi); //tulostetaan -1
System.out.println(sana.substring(indeksi)); //virhe!

Screencast aiheesta:

Anna sana: esimerkki
Alkuosan pituus: 4
Tulos: esim

Anna sana: esimerkki
Alkuosan pituus: 7
Tulos: esimerk

Anna sana: esimerkki
Loppuosan pituus: 4
Tulos: rkki

Anna sana: esimerkki
Loppuosan pituus: 7
Tulos: imerkki

Anna 1. sana: suppilovahvero
Anna 2. sana: ilo
Sana 'ilo' on sanan 'suppilovahvero' osana.

Anna 1. sana: suppilovahvero
Anna 2. sana: suru
Sana 'suru' ei ole sanan 'suppilovahvero' osana.

public static String kaanna(String merkkijono) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    System.out.print("Anna merkkijono: ");
    String merkkijono = lukija.nextLine();
    System.out.println("Väärinpäin: " + kaanna(merkkijono));
}
    

String apu = "";

// ...
// lisätään merkki apu-nimisen muuttujan perään
apu = apu + merkki;

Anna merkkijono: esimerkki
ikkremise
    

15. Oliot ja metodit

Merkkijonot poikkeavat luonteeltaan hieman esim. kokonaisluvuista. Kokonaisluvut ovat "pelkkiä arvoja", niiden avulla voi laskea ja niitä voi tulostella ruudulle:

int x = 1;
int y = 3;

y = 3*x + 2;

System.out.println( "y:n arvo nyt: " + y );
  

Merkkijonot ovat hieman "älykkäämpiä" ja tietävät esimerkiksi pituutensa:

String sana1 = "Ohjelmointi";
String sana2 = "Java";

System.out.println( "merkkijonon "+ sana1 +" pituus: " + sana1.length() );

System.out.println( "merkkijonon "+ sana2 +" pituus: " + sana2.length() );
  

Tulostuu:

merkkijonon Ohjelmointi pituus on 11
merkkijonon Java pituus on 4

Pituus saadaan selville kutsumalla merkkijonon metodia length(). Merkkijonoilla on joukko muitakin metodeja. Kokonaisluvuilla eli int:eillä ei ole metodeja ollenkaan, ne eivät itsessään "osaa" mitään.

Merkkijonot ovat olioita eli "asioita joihin liittyy metodeja sekä arvo". Jatkossa tulemme näkemään hyvin paljon muitakin olioita kuin merkkijonoja.

Kuten edellisestä esimerkistä huomaamme, kutsutaan olion metodia lisäämällä olion nimen perään piste ja metodikutsu:

sana1.length()    // kutsutaan merkkijono-olion sana1 metodia length()
sana2.length()    // kutsutaan merkkijono-olion sana2 metodia length()

Metodikutsu kohdistuu nimenomaan sihen olioon, mille metodia kutsutaan. Yllä kutsumme ensin sana1-nimisen merkkijonon length()-metodia, sitten merkkijonon sana2 metodia length().

Vanha tuttumme lukija on myös olio:

Scanner lukija = new Scanner(System.in);

Lukijat ja merkkijonot ovat molemmat oliota, ne ovat kuitenkin varsin erilaisia. Lukijoilla on mm. metodi nextLine() jota merkkijonoilla ei ole. Javassa oliot "synnytetään" eli luodaan melkein aina komennolla new, merkkijonot muodostavat tässä suhteessa poikkeuksen! -- Merkkijonoja voi luoda kahdella tavalla:

String banaani = new String("Banaani");
String porkkana = "porkkana";

Kumpikin ylläolevista riveistä luo uuden merkkijono-olion. Merkkijonojen luonnissa new-komentoa käytetään hyvin harvoin.

Olion "tyyppiä" sanotaan luokaksi. Merkkijonojen luokka on String, lukijoiden luokka taas on Scanner. Opimme jatkossa luokista ja olioista paljon lisää.

16. ArrayList eli "oliosäiliö"

Ohjelmoidessa tulee usein vastaan tilanteita joissa haluaisimme pitää muistissa esimerkiksi useita erilaisia merkkijonoja. Todella huono tapa olisi määritellä jokaiselle oma muuttujansa:

String sana1;
String sana2;
String sana3;
// ...
String sana10;

Tämä olisi aivan kelvoton ratkaisu ja sen huonoutta ei kannata oikeastaan edes perustella -- ajattele ylläoleva esimerkki vaikkapa sadalla tai tuhannella sanalla.

Java, kuten kaikki modernit ohjelmointikielet, tarjoaa erilaisia apuvälineitä joiden avulla on helppo säilyttää ohjelmassa monia olioita. Tutustumme nyt Javan ehkä eniten käytettyyn oliosäiliöön ArrayList:iin.

Seuraava ohjelmanpätkä ottaa käyttöönsä merkkijono-olioita tallentavan ArrayList:in sekä tallettaa listalle pari merkkijonoa.

import java.util.ArrayList;

public class ListaOhjelma {

    public static void main(String[] args) {
        ArrayList<String> sanaLista = new ArrayList<String>();

        sanaLista.add("Ensimmäinen");
        sanaLista.add("Toinen");
    }
}

Yllä olevan pääohjelman ensimmäinen rivi luo sanaLista-nimisen merkkijonoja tallettavan arraylistin. Listamuuttujan tyypin nimi on ArrayList<String>, eli merkkijonoja tallettava ArrayList. Itse lista luodaan sanomalla new ArrayList<String>();.

Huom: Jotta ArrayList toimisi, on ohjelman ylälaitaan kirjoitettava import java.util.ArrayList; tai import java.util.*;

Kun lista on luotu, siihen lisätään kaksi merkkijonoa kutsumalla listan metodia add. Tila ei lopu listalla missään vaiheessa kesken, eli periaatteessa listalle saa lisätä niin monta merkkijonoa kun "koneen" muistiin mahtuu.

Sisäisesti ArrayList on nimensä mukaisesti lista. Lisätyt merkkijonot menevät automaattisesti ArrayList:in loppuun.

16.1 ArrayList:in metodeja

ArrayList tarjoaa monia hyödyllisiä metodeita:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    opettajat.add("Antti");
    opettajat.add("Arto");
    opettajat.add("Pekka");
    opettajat.add("Juhana");
    opettajat.add("Martin");
    opettajat.add("Matti");

    System.out.println("opettajien lukumäärä " + opettajat.size() );

    System.out.println("listalla ensimmäisenä " + opettajat.get(0));
    System.out.println("listalla kolmantena " + opettajat.get(2));

    opettajat.remove("Arto");

    if ( opettajat.contains("Arto") ) {
        System.out.println("Arto on opettajien listalla");
    } else {
        System.out.println("Arto ei ole opettajien listalla");
    }
}

Ensin luodaan merkkijonolista jolle lisätään 6 nimeä. size kertoo listalla olevien merkkijonojen lukumäärän. Huom: kun metodia kutsutaan, on kutsu muotoa opettajat.size(), eli metodin nimeä edeltää piste ja sen listan nimi kenen metodia kutsutaan.

Merkkijonot ovat listalla siinä järjestyksessä missä ne listalle laitettiin. Metodilla get(i) saadaan tietoon listan paikan i sisältö. Listan alkioiden paikkanumerointi alkaa nollasta, eli ensimmäisenä lisätty on paikassa numero 0, toisen a lisätty paikassa numero 1 jne.

Metodin remove avulla voidaan listalta poistaa merkkijonoja. Jos käytetään metodia muodossa remove("merkkejä"), poistetaan parametrina annettu merkkijono. Metodia voi käyttää myös siten, että annetaan parametriksi tietty luku. Esim. jos sanotaan remove(3) poistuu listalla neljäntenä oleva merkkijono.

Esimerkin lopussa kutsutaan metodia contains jonka avulla kysytään listalta sisältääkö se parametrina annettavan merkkijonon. Jos sisältää, palauttaa metodi arvon true.

Ohjelman tulostus:

opettajien lukumäärä 6
listalla ensimmäisena Antti
listalla kolmantena Pekka
Arto ei ole opettajien listalla

Huom! Metodit remove ja contains olettavat että listaan tallennetuilla olioilla on metodi equals. Palaamme tähän myöhemmin kurssilla.

16.2 ArrayList:in läpikäynti

Seuraavassa esimerkissä lisätään listalle 4 nimeä ja tulostetaan listan sisältö:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    opettajat.add("Antti");
    opettajat.add("Pekka");
    opettajat.add("Juhana");
    opettajat.add("Martin");

    System.out.println( opettajat.get(0) );
    System.out.println( opettajat.get(1) );
    System.out.println( opettajat.get(2) );
    System.out.println( opettajat.get(3) );
}

Ratkaisu on kuitenkin erittäin kömpelö. Entäs jos listalla olisi enemmän alkiota? Tai vähemmän? Entäs jos ei olisi edes tiedossa listalla olevien alkioiden määrää?

Tehdään ensin välivaiheen versio jossa pidetään:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    opettajat.add("Antti");
    opettajat.add("Pekka");
    opettajat.add("Juhana");
    opettajat.add("Martin");
    opettajat.add("Matti");

    int paikka = 0;
    System.out.println( opettajat.get(paikka) );
    paikka++;
    System.out.println( opettajat.get(paikka) );  // paikka = 1
    paikka++;
    System.out.println( opettajat.get(paikka) );  // paikka = 2
    paikka++;
    System.out.println( opettajat.get(paikka) );  // paikka = 3
}

Vanhan tutun while-komennon avulla voimme kasvataa muuttujaa paikka niin kauan kunnes se kasvaa liian suureksi:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    opettajat.add("Antti");
    opettajat.add("Pekka");
    opettajat.add("Juhana");
    opettajat.add("Martin");
    opettajat.add("Matti");

    int paikka = 0;
    while ( paikka < opettajat.size() )  // muistatko miksi paikka <= opettajat.size() ei toimi?
        System.out.println( opettajat.get(paikka) );
        paikka++;
    }
}

Nyt tulostus toimii riippumatta listalla olevien alkioiden määrästä.

While-toistolauseen käyttö ja listan paikkojen "indeksointi" ei kuitenkaan ole yleensä järkevin tapa listan läpikäyntiin. Suositeltavampi on seuraavassa esiteltävä for-each -toistolauseke.

16.3 for-each

Vaikka komennosta käytetään nimitystä for-each, komennon nimi on pelkästään for. for:ista on olemassa kaksi versiota, perinteinen (jonka nopea esittely oli jo viimeviikolla mutta mitä alame varsinaisesti käyttämään vasta viikolla 6) ja "for-each" jota käytämme nyt.

ArrayList:in alkioiden läpikäynti for-each:illa on lasten leikkiä:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    opettajat.add("Antti");
    opettajat.add("Pekka");
    opettajat.add("Juhana");
    opettajat.add("Martin");
    opettajat.add("Matti");

    for (String opettaja : opettajat) {
        System.out.println( opettaja );
    }
}

Kuten huomaame, ei listalla olevien merkkijonojen paikkanumeroista tarvitse välittää, for käy listan sisällön läpi "automaattisesti".

Komennon for aaltosulkujen sisällä olevassa koodissa käytetään muuttujaa opettaja, joka on määritelty for-rivillä kaksoispisteen vasemmalla puolella. Käy niin, että kukin listalla opettajat oleva merkkijono tulee vuorollaan muuttujan opettaja arvoksi. Eli kun for:iin mennään, on opettaja ensin Antti, forin toisella toistolla opettaja on Pekka, jne

Vaikka for-komento voi tuntua aluksi hieman oudolta sitä kannattaa ehdottomasti totutella käyttämään!

Screencast aiheesta:

ArrayList<String> sanat = new ArrayList<String>();

Anna sana: Mozart
Anna sana: Schubert
Anna sana: Bach
Anna sana: Sibelius
Anna sana: Liszt
Anna sana:
Annoit seuraavat sanat:
Mozart
Schubert
Bach
Sibelius
Liszt

String sana = lukija.nextLine();

if ( sana.isEmpty() ) {  // myös tämä tomisi: sana.equals("")
    // sana oli tyhjä eli pelkkä enterin painallus
}

ArrayList<String> sanat = new ArrayList<String>();

Anna sana: porkkana
Anna sana: selleri
Anna sana: nauris
Anna sana: lanttu
Anna sana: selleri
Annoit uudestaan sanan selleri

16.4 Listan järjestäminen, kääntäminen ja sekoittaminen

ArrayList:n sisältö on helppo järjestää suuruusjärjestykseen. Suuruusjärjestys merkkijonojen yhteydessä tarkoittaa aakkosjärjestystä. Järjestäminen tapahtuu seuraavasti:

public static void main(String[] args) {
    ArrayList<String> opettajat = new ArrayList<String>();

    // ...

    Collections.sort(opettajat);

    for (String opettaja : opettajat) {
        System.out.println( opettaja );
    }
}

Tulostuu:

Antti
Arto
Juhana
Martin
Matti
Pekka

Annetaan siis lista parametriksi metodille Collections.sort. Jotta Collections:in apuvälineet toimisivat, on ohjelman yläosassa oltava import java.util.Collections; tai import java.util.*;

Collections:ista löytyy muutakin hyödyllistä:

• shuffle sekoittaa listan sisällön, metodista voi olla hyötyä esimerkiksi peleissä
• reverse kääntää listan sisällön

Anna sana: Mozart
Anna sana: Schubert
Anna sana: Bach
Anna sana: Sibelius
Anna sana: Liszt
Anna sana:
Annoit seuraavat sanat:
Liszt
Sibelius
Bach
Schubert
Mozart

Anna sana: Mozart
Anna sana: Schubert
Anna sana: Bach
Anna sana: Sibelius
Anna sana: Liszt
Anna sana:
Annoit seuraavat sanat:
Bach
Liszt
Mozart
Schubert
Sibelius

16.5 ArrayList metodin parametrina

ArrayList:in voi antaa metodille parametrina:

public static void tulosta(ArrayList<String> lista) {
    for (String sana : lista) {
        System.out.println( sana );
    }
}

public static void main(String[] args) {
    ArrayList<String> lista = new ArrayList<String>();
    lista.add("Java");
    lista.add("Python");
    lista.add("Ruby");
    lista.add("C++");

    tulosta(lista);
}

Parametrin tyyppi siis määritellään listaksi täsmälleen samalla tavalla eli ArrayList<String> kuin listamuuttujan määrittely tapahtuu.

Huomaa, että parametrin nimellä ei ole merkitystä:

public static void tulosta(ArrayList<String> tulostettava) {
    for (String sana : tulostettava) {
        System.out.println( sana );
    }
}

public static void main(String[] args) {
    ArrayList<String> ohjelmointikielet = new ArrayList<String>();
    ohjelmointikielet.add("Java");
    ohjelmointikielet.add("Python");
    ohjelmointikielet.add("Ruby");
    ohjelmointikielet.add("C++");

    ArrayList<String> maat = new ArrayList<String>();
    maat.add("Suomi");
    maat.add("Ruotsi");
    maat.add("Norja");

    tulosta(ohjelmointikielet);    // annetaan metodille parametriksi lista ohjelmointikielet

    tulosta(maat);                 // annetaan metodille parametriksi lista maat
}

Ohjelmassa on nyt kaksi listaa ohjelmointikielet ja maat. Metodille annetaan ensin tulostettavaksi lista ohjelmointikielet. Metodi tulosta käyttää parametriksi saamastaan listasta sisäisesti nimellä tulostettava! Seuraavaksi metodille annetaan tulostettavaksi lista maat. Jälleen metodi käyttää parametrinaan saamasta listasta sisäisesti nimeä tulostettava.

ArrayList<String> lista = new ArrayList<String>();
lista.add("Moi");
lista.add("Ciao");
lista.add("Hello");
System.out.println("Listalla on alkioita:");
System.out.println(laskeAlkiot(lista));

Listalla on alkioita:
3

Metodin sisällä on mahdollisuus vaikuttaa parametrina saadun listan sisältöön. Seuraavassa esimerkissä metodi poistaEnsimmainen nimensä mukaisesti poistaa listalla ensimmäisenä olevan merkkijonon (mitähän tapahtuu jos listalla ei ole mitään?).

public static void tulosta(ArrayList<String> tulostettava) {
    for (String sana : tulostettava) {
        System.out.println( sana );
    }
}

public static void poistaEnsimmainen(ArrayList<String> lista) {
    lista.remove(0);  // poistetaan listalta ensimmäinen eli "nollas"
}

public static void main(String[] args) {
    ArrayList<String> ohjelmointikielet = new ArrayList<String>();
    ohjelmointikielet.add("Pascal");
    ohjelmointikielet.add("Java");
    ohjelmointikielet.add("Python");
    ohjelmointikielet.add("Ruby");
    ohjelmointikielet.add("C++");


    tulosta(ohjelmointikielet);

    poistaEnsimmainen(ohjelmointikielet);

    System.out.println();  // tulostetaan tyhjä rivi

    tulosta(ohjelmointikielet);
}

Tulostuu:

Pascal
Java
Python
Ruby
C++

Java
Python
Ruby
C++

Vastaavalla tavalla metodi voisi esim. lisätä parametrina saamaansa listaan lisää merkkijonoja.

ArrayList<String> tyypit = new ArrayList<String>();
tyypit.add("Pekka");
tyypit.add("Mauri");
tyypit.add("Jore");
tyypit.add("Simppa");

System.out.println("Tyypit:");
System.out.println(tyypit);

// tyypit järjestykseen!
tyypit.sort();

// heitetään viimeinen mäkeen!
poistaViimeinen(tyypit);

System.out.println(tyypit);

Tyypit:
[Pekka, Mauri, Jore, Simppa]
[Jore, Mauri, Pekka]

Kuten edellisen tehtävän esimerkkitulostuksesta näemme, voi ArrayList:in tulostaa sellaisenaan. Tulostusmuoto ei kuitenkaan yleensä ole halutun kaltainen ja tulostus joudutaan hoitamaan itse esim. for-komennon avulla.

16.6 Lukuja ArrayList:issä

ArrayList:eihin voi tallettaa minkä tahansa tyyppisiä arvoja. Jos talletetaan kokonaislukuja eli int:ejä, tulee muistaa pari detaljia. int:ejä tallettava lista tulee määritellä ArrayList<Integer>, eli int:n sijaan tulee kirjoittaa Integer.

Kun listalle talletetaan int-lukuja, ei metodi remove toimi aivan odotetulla tavalla:

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

    luvut.add(4);
    luvut.add(8);

    // yrittää poistaa luvun listan kohdasta 4, eli ei toimi odotetulla tavalla!
    luvut.remove(4);

    // tämä poistaa listalta luvun 4
    luvut.remove( Integer.valueOf(4) );
}

Eli luvut.remove(4) yrittää poistaa listalla kohdassa 4 olevan alkion. Listalla on vain 2 alkiota, joten komento aiheuttaa virheen. Jos halutaan poistaa luku 4, täytyy käyttää hieman monimutkaisempaa muotoa: luvut.remove( Integer.valueOf(4) );

Listalle voi tallettaa myös liukulukuja eli double:ja ja merkkejä eli char:eja. Tällöin listat luodaan seuraavasti:

ArrayList<Double> doublet = new ArrayList<Double>();
ArrayList<Character> merkit = new ArrayList<Character>();
    

public static int summa(ArrayList<Integer> lista) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<Integer>();
    lista.add(3);
    lista.add(2);
    lista.add(7);
    lista.add(2);

    System.out.println("Summa: " + summa(lista));

    lista.add(10);

    System.out.println("Summa: " + summa(lista));
}
  

Summa: 14
Summa: 24

public static double keskiarvo(ArrayList<Integer> lista) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<Integer>();
    lista.add(3);
    lista.add(2);
    lista.add(7);
    lista.add(2);

    System.out.println("Keskiarvo: " + keskiarvo(lista));
}

Keskiarvo: 3.5

public static int suurin(ArrayList<Integer> lista) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<Integer>();
    lista.add(3);
    lista.add(2);
    lista.add(7);
    lista.add(2);

    System.out.println("Suurin: " + suurin(lista));
}

Suurin: 7

public static double varianssi(ArrayList<Integer> lista) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<Integer>();
    lista.add(3);
    lista.add(2);
    lista.add(7);
    lista.add(2);

    System.out.println("Varianssi: " + varianssi(lista));
}

  Varianssi: 5.666667

17. Totuusarvojen käyttö

Totuusarvoinen eli boolean-muuttuja voi saada vain kaksi arvoa true tai false. Seuraavassa esimerkki booleanin käytöstä:

int luku1 = 1;
int luku2 = 5;

boolean ekaSuurempi = true;

if (luku1 <= luku2) {
    ekaSuurempi = false;
}

if (ekaSuurempi==true) {
    System.out.println("luku1 suurempi");
} else {
    System.out.println("luku1 ei ollut suurempi");
}

Eli ensin asetetaan totuusarvon ekaSuurempi arvoksi tosi eli true. Ensimmäinen if tarkastaa onko luku1 pienempi tai yhtä pieni kuin luku2. Jos näin on, vaihdetaan totuusarvon arvoksi epätosi eli false. Myöhempi if valitsee tulostuksen totuusarvoon perustuen.

Totuusarvon käyttö ehtolauseessa on itseasiassa edellistä esimerkkiä yksinkertaisempaa, jälkimmäinen if voidaan kirjoittaa seuraavasti:

if (ekaSuurempi) {  // tarkoittaa samaa kuin ekaSuurempi==true
    System.out.println("luku1 suurempi");
} else {
    System.out.println("luku1 ei ollut suurempi");
}

Eli jos halutaan tarkistaa että booleanmuuttujan arvo on tosi, eli ole tarvetta kirjoittaa ==true, pelkkä muuttujan nimi riittää!

Epätoden tarkastaminen onnistuu negaatio-operaation eli huutomerkin avulla:

if (!ekaSuurempi) {  // tarkoittaa samaa kuin ekaSuurempi==false
    System.out.println("luku1 ei ollut suurempi");
} else {
    System.out.println("luku1 suurempi");
}

17.1 totuusarvon palauttava metodi

Totuusarvot ovat erityisen käteviä jonkun asian voimassaolon tarkistavien metodien paluuarvoina. Tehdään metodi joka tarkastaa sisältääkö sen parametrina saama lista ainoastaan positiivisia lukuja (tulkitaan 0 positiiviseksi). Tieto positiivisuudesta palautetaan totuusarvona.

public static boolean kaikkiPositiivisia(ArrayList<Integer> luvut) {
    boolean eiNegatiivisia = true;

    for (int luku : luvut) {
        if (luku < 0) {
            eiNegatiivisia = false;
        }
    }
    // jos jonkun listan luvuista arvo oli pienempi kuin 0, on eiNegatiivisia nyt false
    return eiNegatiivisia;
}

Metodilla on totuusarvoinen apumuuttuja eiNegatiivisia. Apumuuttujan arvoksi asetetaan ensin true. Metodi käy läpi kaikki listan luvut. Jos jonkun (siis vähintään yhden) luvun arvo on pienempi kuin nolla, asetetaan apumuuttujan arvoksi false. Lopuksi palautetaan apumuuttujan arvo. Apumuuttuja on edelleen true jos yhtään negatiivista lukua ei löytynyt, muuten false.

Metodia käytetään seuraavasti:

public static void main(String[] args) {

    ArrayList<Integer> luvut = new ArrayList<Integer>();
    luvut.add(3);
    luvut.add(1);
    luvut.add(-1);

    boolean vastaus = kaikkiPositiivisia(luvut);

    if (vastaus) {  // tarkoittaa siis samaa kuin vastaus == true
        System.out.println("luvut positiivisia");
    } else {
        System.out.println("joukossa oli ainakin yksi negatiivinen");
    }
}

Vastauksen tallettaminen ensin muuttujaan ei yleensä ole tarpeen, ja metodikutsu voidaan kirjottaa suoraan ehdoksi:

ArrayList<Integer> luvut = new ArrayList<Integer>();
luvut.add(4);
luvut.add(7);
luvut.add(12);
luvut.add(9);

if (kaikkiPositiivisia(luvut)) {
    System.out.println("luvut positiivisia");
} else {
    System.out.println("joukossa oli ainakin yksi negatiivinen");
}

17.2 Komento return ja metodin lopetus

Metodin suoritus loppuu välittömästi kun metodissa suoritetaan return-käsky. Käyttämällä tätä tietoa hyväksi voimme kirjoittaa kaikkiPositiivisia-metodin hiukan suoraviivaisemmin ja selkeämmin.

public static boolean kaikkiPositiivisia(ArrayList<Integer> luvut) {
    for (int luku : luvut) {
        if (luku < 0) {
            return false;
        }
    }

    // jos tultiin tänne asti, ei yhtään negatiivista löytynyt
    // siispä palautetaan true
    return true;
    }
}

Eli jos lukujen listaa läpikäydessä törmätään negatiiviseen lukuun, voidaan metodista poistua heti palauttamalla false. Jos listalla ei ole yhtään negatiivista, päädytään loppuun ja voidaan palauttaa true. Olemme päässeet metodissa kokonaan eroon apumuuttujan käytöstä!

public static boolean onkoListallaUseasti(ArrayList<Integer> lista, int luku) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<Integer>();
    lista.add(3);
    lista.add(2);
    lista.add(7);
    lista.add(2);

    System.out.println("Anna luku: ");
    int luku = Integer.parseInt(lukija.nextLine());
    if (onkoListallaUseasti(luvut, luku)) {
        System.out.println(luku + " on listalla useasti.");
    } else {
        System.out.println(luku + " ei ole listalla useasti.");
    }
}

  Anna luku: 2
  Luku on on listalla useasti.

  Anna luku: 3
  Luku ei ole listalla useasti.

public static boolean palindromi(String merkkijono) {
    // kirjoita koodia tähän
}

public static void main(String[] args) {
    Scanner lukija = new Scanner(System.in);

    System.out.println("Anna merkkijono: ");
    String merkkijono = lukija.nextLine();
    if (palindromi(merkkijono)) {
        System.out.println("Merkkijono on palindromi!");
    } else {
        System.out.println("Merkkijono ei ole palindromi!");
    }
}

Anna merkkijono: saippuakauppias
Merkkijono on palindromi!

Anna merkkijono: esimerkki
Merkkijono ei ole palindromi!

17.3 ArrayListin kopioiminen

Joskus on tarpeen muodostaa ArrayLististä kopio, johon voi tehdä muutoksia vaikuttamatta alkuperäisen ArrayListin sisältöön. Kopion voi muodostaa luomalla uuden ArrayListin käyttäen vanhaa ArrayListiä parametrina:

ArrayList<String> nimet = new ArrayList<String>();
nimet.add("Kyösti");
nimet.add("Risto");
nimet.add("Carl");
nimet.add("Urho");

//luodaan kopio nimet-listasta
ArrayList<String> kopio = new ArrayList<String>(nimet);
//järjestetään kopio
Collections.sort(kopio);

System.out.println(kopio);  //tulostuu [Carl, Kyösti, Risto, Urho]
System.out.println(nimet);  //tulostuu [Kyösti, Risto, Carl, Urho]

public static void main(String[] args) {
    ArrayList<Integer> lista1 = new ArrayList<Integer>();
    lista1.add(3);
    lista1.add(7);
    lista1.add(1);

    boolean eri = kaikkiEri(lista1);
    // muuttujan eri arvo true

    ArrayList<Integer> lista2 = new ArrayList<Integer>();
    lista2.add(2);
    lista2.add(3);
    lista2.add(7);
    lista2.add(1);
    lista2.add(3);
    lista2.add(99);

    eri = kaikkiEri(lista2);
    // muuttujan eri arvo false sillä luku 3 on listalla kahteen kertaan
}

18. Metodit ja parametrien kopioituminen

Tarkastellaan muutamaa metodeihin liittyvää tärkeää yksityiskohtaa.

Luvussa 15 oli esimerkki, jossa yritettiin muuttaa pääohjelmassa olevan muuttujan arvoa metodin sisällä.

public static void main(String[] args) {
    int luku = 1;
    kasvataKolmella();
    System.out.println("luku on " + luku);
}

public static void kasvataKolmella() {
    luku = luku + 3;
}

Ohjelma ei toimi, sillä metodi ei pääse käsiksi pääohjelman muuttujaan luku.

Tämä johtuu siitä, että pääohjelman muuttujat eivät näy metodien sisään. Ja yleisemmin: minkään metodin muuttujat eivät näy muille metodeille. Koska pääohjelma main on myös metodi, pätee sääntö myös pääohjelmalle. Ainoa keino viedä metodille tietoa ulkopuolelta on parametrin avulla.

Yritetään korjata edellinen esimerkki välittämällä pääohjelman muuttuja luku parametrina metodille.

public static void main(String[] args) {
    int luku = 1;
    kasvataKolmella(luku);
    System.out.println(luku);  // tulostaa 1, eli arvo luku ei muuttunut
}

public static void kasvataKolmella(int luku) {
    luku = luku + 3;
}

Ohjelma ei toimi toivotulla tavalla. Metodissa olevat parametrit ovat eri muuttujia kuin pääohjelmassa esitellyt muuttujat. Edellä metodi siis kasvattaa samannimistä, mutta ei samaa parametria luku.

Kun metodille annetaan parametri, parametrin arvo kopioidaan uuteen muuttujaan metodissa käytettäväksi. Yllä olevassa esimerkissä metodille kasvataKolmella annetusta muuttujasta luku luodaan kopio, jota metodin sisällä lopulta käsitellään. Metodi käsittelee siis pääohjelmassa olevan muuttujan kopiota, ei alkuperäistä muuttujaa -- pääohjelmametodissa olevalle muuttujalle luku ei tehdä mitään.

Voidaan ajatella, että pääohjelmametodi main ja metodi kasvataKolmella toimivat kumpikin omassa kohtaa tietokoneen muistia. Allaolevassa kuvassa on main:in muuttujaa luku varten oma "lokero". Kun metodia kutsutaan, tehdään tälle oma muuttuja luku jonka arvoksi kopioituu main:in luku-muuttujan arvo eli 1. Molemmat luku-nimiset muuttujat ovat kuitenkin täysin erillisiä, eli kun metodissa kasvataKolmella muutetaan sen luku-muuttujan arvoa, ei muutos vaikuta millään tavalla pääohjelman muuttujaan luku.

Allaoleva kuva antaa lisävalaisua tilanteeseen.

Metodista saa toki välitettyä tietoa kutsujalle käyttäen paluuarvoa, eli palauttamalla arvon return-komennolla. Edellinen saadaan toimimaan muuttamalla koodia hiukan:

public static void main(String[] args) {
    int luku = 1;
    luku = kasvataKolmellaJaPalauta(luku);

    System.out.println(luku);  // tulostaa 4, sillä luku on saanut arvokseen metodin palauttaman arvon
}

public static int kasvataKolmellaJaPalauta(int luku) {
    luku = luku + 3;

    return luku;
}

Edelleen on niin, että metodi käsittelee pääohjelman luku-muuttujan arvon kopiota. Pääohjelmassa metodin palauttama arvo sijoitetaan muuttujaan luku, joten muutos tulee tämän takia voimaan myös pääohjelmassa. Huomaa, että edellisessä ei ole mitään merkitystä sillä, mikä nimi metodin parametrilla on. Koodi toimii täysin samoin oli nimi mikä tahansa, esim.

public static void main(String[] args) {
    int luku = 1;
    luku = kasvataKolmellaJaPalauta(luku);

    System.out.println(luku);
}

public static int kasvataKolmellaJaPalauta(int kasvatettavaLuku) {
    kasvatettavaLuku = kasvatettavaLuku + 3;

    return kasvatettavaLuku;
}

Huomasimme että metodissa olevat parametrit ovat eri muuttujia kuin metodin kutsujassa esitellyt muuttujat. Ainoastaan parametrin arvo kopioituu kutsujasta metodiin.

Asia ei kuitenkaan ole ihan näin yksinkertainen. Jos metodille annetaan parametrina ArrayList, käy niin että sama lista näkyy metodille ja kaikki metodin listalle tekemät muutokset tulevat kaikkialla voimaan.

public static void poistaAlussaOleva(ArrayList<Integer> lista) {
    lista.remove(0); // poistaa paikassa 0 olevan luvun
}

ArrayList<Integer> luvut = new ArrayList<Integer>();
luvut.add(4);
luvut.add(3);
luvut.add(7);
luvut.add(3);

System.out.println(luvut); // tulostuu [4,3,7,3]

poistaAlussaOleva(luvut);

System.out.println(luvut); // tulostuu [3,7,3]

Toisin kuin int-tyyppinen parametri, lista ei kopioidu vaan metodi käsittelee suoraan parametrina annettua listaa.

Tilannetta valaisee allaoleva kuva. Toisin kuin int-tyyppinen muuttuja, ArrayList ei sijaitsekaan samalla tapaa "lokerossa", vaan muuttujan nimi, eli mainin tapauksessa luvut onkin ainoastaan viite paikkaan missä ArrayList sijaitsee. Yksi tapa ajatella asiaa, on että ArrayList on "langan päässä", eli listan nimi luvut on lanka jonka toisesta päästä lista löytyy. Kun metodikutsun parametrina on ArrayList, käykin niin että metodille annetaan "lanka" jonka päässä on sama lista jonka metodin kutsuja näkee. Eli main:illa ja metodilla on kyllä molemmilla oma lanka, mutta langan päässä on sama lista ja kaikki muutokset mitä metodi tekee listaan tapahtuvat täsmälleen samaan listaan jota pääohjelma käyttää. Tästä viikosta alkaen tulemme huomaamaan että Java:ssa hyvin moni asia on "langan päässä".

Huomaa jälleen että parametrin nimi metodin sisällä voi olla aivan vapaasti valittu, nimen ei tarvitse missään tapauksessa olla sama kuin kutsuvassa metodissa oleva nimi. Edellä listaa kutsutaan metodin sisällä nimellä lista, metodin kutsuja taas näkee saman listan luvut-nimisenä.

Miksi int-parametrista ainoastaan arvo kopioituu metodille mutta parametrin ollessa ArrayList metodi käsittelee suoraan listan sisältöä? Javassa ainoastaan alkeistietotyyppisten eli tyyppien int, double, char, boolean (ja muutamien muiden joita emme ole käsitelleet) arvot kopioidaan metodille. Muun tyyppisten parametrien tapauksessa metodille kopioidaan viite, ja metodista käsitellään viitteen takana olevaa parametria suoraan. Ei-alkeistyyppiset muuttujat -- eli viittaustyyppiset muuttujat ovat siis edellisen kuvan tapaan "langan päässä" -- metodille välitetään lanka parametriin, ja näin metodi käsittelee parametria suoraan.

ArrayList<Integer> lista1= new ArrayList<Integer>();
ArrayList<Integer> lista2= new ArrayList<Integer>();

lista1.add(4);
lista1.add(3);

lista2.add(5);
lista2.add(10);
lista2.add(7);

yhdista(lista1, lista2);

System.out.println(lista1); // tulostuu [4, 3, 5, 10, 7]

System.out.println(lista2); // tulostuu [5, 10, 7]