Fincer
/
java-basics
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Add base files

master
Pekka Helenius 5 years ago
parent
62a40a9d2e
commit
a25aaaab8a
61 changed files with 4783 additions and 2 deletions
Split View
  1. +95
    -0
      10_classes-and-objects/1_AutoOhjelma.md
  2. +72
    -0
      10_classes-and-objects/2_Agentti.md
  3. +134
    -0
      10_classes-and-objects/3_VahenevaLaskuri.md
  4. +96
    -0
      10_classes-and-objects/4_Artist.md
  5. +162
    -0
      10_classes-and-objects/5_Artist_Song.md
  6. +127
    -0
      10_classes-and-objects/6_Playlist.md
  7. +320
    -0
      10_classes-and-objects/7_KirjaOhjelma.md
  8. +188
    -0
      10_classes-and-objects/8_AsuntoOhjelma.md
  9. +110
    -0
      10_classes-and-objects/9_RemonttiOhjelma.md
  10. +19
    -0
      1_basics/1_TerveMaailma.md
  11. +38
    -0
      1_basics/2_HeiEtunimi.md
  12. +32
    -0
      1_basics/3_Puoluetuki.md
  13. +38
    -0
      1_basics/4_Bitcoin.md
  14. +53
    -0
      1_basics/5_Pikavippi.md
  15. +43
    -0
      1_basics/6_Maalaus.md
  16. +35
    -0
      1_basics/7_Cooper.md
  17. +41
    -0
      1_basics/8_Juhlat.md
  18. +44
    -0
      1_basics/9_LukujenSumma.md
  19. +30
    -0
      2_conditionals/1_Ylinopeus.md
  20. +68
    -0
      2_conditionals/2_Katsastus.md
  21. +103
    -0
      2_conditionals/4_Palkka.md
  22. +82
    -0
      2_conditionals/5_Peltipoliisi.md
  23. +122
    -0
      3_loops/1_Toisto.md
  24. +63
    -0
      3_loops/2_Kilometrikorvaus.md
  25. +62
    -0
      3_loops/3_Kotitalousvahennys.md
  26. +113
    -0
      3_loops/4_Opintopisteet.md
  27. +95
    -0
      3_loops/5_Lahtolaskenta.md
  28. +67
    -0
      3_loops/6_Alkuluku.md
  29. +57
    -0
      4_strings/1_MerkkijonojenVertailu.md
  30. +18
    -0
      4_strings/2_HelloWorld.md
  31. +71
    -0
      4_strings/3_Lumi.md
  32. +61
    -0
      4_strings/4_Tuotteet.md
  33. +40
    -0
      4_strings/5_Osamerkkijonot.md
  34. +76
    -0
      4_strings/6_Lento.md
  35. +54
    -0
      4_strings/7_RekisterinumeroTarkistin.md
  36. +77
    -0
      5_lists/10_KysytynLuvunIndeksi.md
  37. +64
    -0
      5_lists/11_LustanLukujenSumma.md
  38. +64
    -0
      5_lists/12_ListanLukujenKeskiarvo.md
  39. +68
    -0
      5_lists/13_LoytyykoListalta.md
  40. +139
    -0
      5_lists/14_KaupungitVerkosta.md
  41. +53
    -0
      5_lists/1_KolmannenArvonTulostaminen.md
  42. +71
    -0
      5_lists/2_ToisenJaKolmannenSumma.md
  43. +40
    -0
      5_lists/3_IndexOutOfBounds.md
  44. +56
    -0
      5_lists/4_ListanKoko.md
  45. +60
    -0
      5_lists/5_ListanViimeinenArvo.md
  46. +61
    -0
      5_lists/6_EnsimmainenJaViimeinenArvo.md
  47. +63
    -0
      5_lists/7_ListanLuvut.md
  48. +79
    -0
      5_lists/8_LuvutRajatullaAlueella.md
  49. +91
    -0
      5_lists/9_ListanSuurinLuku.md
  50. +38
    -0
      6_tables/1_MerkkijononPalat.md
  51. +73
    -0
      6_tables/2_SanojenVaihtaminen.md
  52. +97
    -0
      6_tables/3_MarsinLampotilat.md
  53. +86
    -0
      7_methods/1_TulostaRajatut.md
  54. +67
    -0
      7_methods/2_Summa.md
  55. +66
    -0
      7_methods/3_PoistaViimeinen.md
  56. +52
    -0
      7_methods/4_Laskuoperaatiot.md
  57. +118
    -0
      7_methods/5_Numerot.md
  58. +67
    -0
      8_lottery_bonus/1_Leikkaus.md
  59. +223
    -0
      8_lottery_bonus/2_Lotto.md
  60. +37
    -0
      9_clitools/1_Erapaiva.md
  61. +44
    -2
      README.md

+ 95
- 0
10_classes-and-objects/1_AutoOhjelma.md View File

@ -0,0 +1,95 @@
Tässä tehtävässä harjoitellaan olioiden luomista ja niiden metodien kutsumista käyttäen apuna alla olevaa valmista Auto-luokkaa. Tallenna tehtävänannon lopussa oleva luokka itsellesi tiedostoon Auto.java ja luo uusi luokka AutoOhjelma, jonka main-metodissa teet seuraavat toimenpiteet:
1) Luo uusi "Tesla"-merkkinen auto ja laita viittaus tähän olioon talteen muuttujaan
2) Luo toinen "BMW"-merkkinen auto ja laita viittaus tähän olioon talteen eri muuttujaan
3) Kutsu Teslan aja-metodia arvolla 100.
4) Kutsu BMW:n aja-metodia arvolla 98.
5) Kutsu Teslan aja-metodia arvolla 23.
6) Tulosta Teslan merkkijonoesitys (toString) omalle rivilleen
7) Tulosta BMW:n merkkijonoesitys (toString) omalle rivilleen
Huom! Koska kilometrit on yksityinen muuttuja, sen arvoa ei voida muuttaa luokan ulkopuolelta. Sinun on siis muutettava arvoa julkisen aja-metodin kautta.
```
/**
* Tallenna tämä luokka itsellesi Auto.java-nimiseen tiedostoon.
*/
public class Auto {
/*
* Nämä muuttujat ovat jokaiselle autolle yksilölliset ja ne säilyvät koko olion
* olemassaolon ajan.
*/
private String merkki;
private int kilometrit;
/**
* Tällä konstruktorilla alustetaan olion muuttujiin new-luontikäskyssä annetut
* arvot.
*
* @param merkki
*/
public Auto(String merkki) {
this.merkki = merkki;
this.kilometrit = 0;
}
/**
* Tällä julkisella metodilla tarjotaan ulkopuolisille luokille mahdollisuus
* muuttaa auton matkamittaria.
*
* @param kilometrit Kasvatettava kilometrimäärä kokonaislukuna
*/
public void aja(int kilometrit) {
this.kilometrit += kilometrit;
}
/**
* toString-metodin avulla olioista voidaan muodostaa automaattisesti loogisia
* merkkijonoesityksiä.
*/
@Override
public String toString() {
return this.merkki + ", " + this.kilometrit + " km.";
}
}
```
Älä palauta Auto-luokkaa Viopeen, se löytyy Viopesta valmiina.
```
Example output:
Tesla, 123 km.
BMW, 98 km.
```
------------------
```
/*
1. Luo uusi "Tesla"-merkkinen auto ja laita viittaus tähän olioon talteen muuttujaan
2. Luo toinen "BMW"-merkkinen auto ja laita viittaus tähän olioon talteen eri muuttujaan
3. Kutsu Teslan aja-metodia arvolla 100.
4. Kutsu BMW:n aja-metodia arvolla 98.
5. Kutsu Teslan aja-metodia arvolla 23.
6. Tulosta Teslan merkkijonoesitys (toString) omalle rivilleen
7. Tulosta BMW:n merkkijonoesitys (toString) omalle rivilleen
*/
public class AutoOhjelma {
public static void main(String[] args) {
Auto Tesla = new Auto("Tesla");
Auto BWM = new Auto("BMW");
Tesla.aja(100);
BWM.aja(98);
Tesla.aja(23);
System.out.println(Tesla.toString());
System.out.println(BWM.toString());
}
}
```

+ 72
- 0
10_classes-and-objects/2_Agentti.md View File

@ -0,0 +1,72 @@
Tässä tehtävässä harjoittelemme toString-metodin määrittelyä muokkaamalla valmista koodia. Seuraavaksi on esitetty luokka Agentti, jolla on etunimi ja sukunimi:
```
public class Agentti {
private String etunimi;
private String sukunimi;
public Agentti(String etunimi, String sukunimi) {
this.etunimi = etunimi;
this.sukunimi = sukunimi;
}
public void tulosta() {
System.out.println("My name is " + sukunimi + ", " + etunimi + " " + sukunimi);
}
}
```
Luokalle on määritelty metodi tulosta, joka luo seuraavanlaisen merkkijonoesityksen:
```
Agentti bond = new Agentti("James", "Bond");
bond.tulosta(); // Tulostaa: My name is Bond, James Bond
```
Tallenna luokka itsellesi tiedostoon Agentti.java ja poista luokan metodi tulosta. Luo luokalle uusi metodi public String toString(), joka palauttaa edellämainitun merkkijonoesityksen.
Luokan tulee toimia jatkossa seuraavasti:
```
Agentti bond = new Agentti("James", "Bond");
bond.toString(); // ei tulosta mitään
System.out.println(bond); // Tulostaa: My name is Bond, James Bond
Agentti ionic = new Agentti("Ionic", "Bond");
System.out.println(ionic); // Tulostaa: My name is Bond, Ionic Bond
```
```
Example output:
= Suoritetaan koodi =
Agentti agentti = new Agentti("Johnny" , "English");
System.out.println(agentti);
= Ohjelman tuloste =
My name is English, Johnny English
```
------------------
```
public class Agentti {
private String etunimi;
private String sukunimi;
public Agentti(String etunimi, String sukunimi) {
this.etunimi = etunimi;
this.sukunimi = sukunimi;
}
/*
public void tulosta() {
System.out.println("My name is " + sukunimi + ", " + etunimi + " " + sukunimi);
}
*/
public String toString() {
return "My name is " + this.etunimi + ", " + this.sukunimi;
}
}
```

+ 134
- 0
10_classes-and-objects/3_VahenevaLaskuri.md View File

@ -0,0 +1,134 @@
Tässä tehtävässä harjoittelemme oliomuuttujien käyttöä. Tallenna osittain toteutettu luokka VahenevaLaskuri itsellesi tiedostoon VahenevaLaskuri.java:
```
public class VahenevaLaskuri {
private int arvo; // oliomuuttuja joka muistaa laskurin arvon
public VahenevaLaskuri(int arvoAlussa) {
this.arvo = arvoAlussa;
}
public void tulostaArvo() {
System.out.println("arvo: " + this.arvo);
}
public void vahene() {
// kirjoita tänne metodin toteutus
// laskurin arvon on siis tarkoitus vähentyä yhdellä
}
// ja tänne muut metodit
}
Seuraavassa esimerkki miten pääohjelma käyttää vähenevää laskuria:
public class Paaohjelma {
public static void main(String[] args) {
VahenevaLaskuri laskuri = new VahenevaLaskuri(10);
laskuri.tulostaArvo();
laskuri.vahene();
laskuri.tulostaArvo();
laskuri.vahene();
laskuri.tulostaArvo();
}
}
```
```
Pitäisi tulostua:
arvo: 10
arvo: 9
arvo: 8
```
VahenevaLaskuri-luokan konstruktorille annetaan parametrina alkuarvo. Esimerkin oliota laskuri luodessa laskurille välitetään parametrina arvo 10. Esimerkin laskuri-olioon liittyvään oliomuuttujaan arvoasetetaan siis aluksi arvo 10. Laskurin arvon voi tulostaa metodilla tulostaArvo(). Laskurilla tulee myös olla metodi vahene() joka vähentää laskurin arvoa yhdellä.
--------------------
Osa 1: Metodin vahene() toteutus
Täydennä luokan runkoon metodin vahene() toteutus sellaiseksi, että se vähentää arvo -oliomuuttujaa yhdellä. Kun olet toteuttanut metodin vahene(), edellisen esimerkin pääohjelman tulee toimia esimerkkitulosteen mukaan.
Osa 2: Laskurin arvo ei saa olla negatiivinen
Täydennä metodin vahene() toteutus sellaiseksi, ettei laskurin arvo mene koskaan negatiiviseksi. Eli jos laskurin arvo on jo 0, ei vähennys sitä enää vähennä. Ehtolause auttaa tässä.
Osa 3: Laskurin arvon nollaus
Tee laskurille metodi public void nollaa() joka nollaa laskurin arvon, esim:
```
public class Paaohjelma {
public static void main(String[] args) {
VahenevaLaskuri laskuri = new VahenevaLaskuri(100);
laskuri.tulostaArvo();
laskuri.nollaa();
laskuri.tulostaArvo();
laskuri.vahene();
laskuri.tulostaArvo();
}
}
```
```
Tulostaa:
arvo: 100
arvo: 0
arvo: 0
```
Huom! Hyödynnä tehtäväkuvauksessa annettuja Paaohjelma-esimerkkiluokkia ohjelmasi testaamisessa. VahenevaLaskuri-luokkasi ei saa sisältää main-metodia. Älä palauta Paaohjelma-luokkaa Viopeen.
```
Example output:
== Testikoodi ==
VahenevaLaskuri laskuri = new VahenevaLaskuri(10)
laskuri.tulostaArvo();
laskuri.vahene();
laskuri.tulostaArvo();
laskuri.vahene();
laskuri.tulostaArvo();
== Ohjelman tuloste ==
arvo: 10
arvo: 9
arvo: 8
```
------------------
```
public class VahenevaLaskuri {
private int arvo; // oliomuuttuja joka muistaa laskurin arvon
public VahenevaLaskuri(int arvoAlussa) {
this.arvo = arvoAlussa;
}
public void tulostaArvo() {
System.out.println("arvo: " + this.arvo);
}
public void vahene() {
if (this.arvo > 0) {
this.arvo -= 1;
}
}
public void nollaa() {
this.arvo = 0;
}
}
```

+ 96
- 0
10_classes-and-objects/4_Artist.md View File

@ -0,0 +1,96 @@
Alla on puutteellisesti toteutettu luokka Artist. Tallenna luokka itsellesi tiedostoon Artist.java ja täydennä get- ja set-metodien toteutus siten, että ne palauttavat ja asettavat artistin nimen sekä syntymävuoden tarkoituksenmukaisesti.
```
public class Artist {
private String name;
private int yearOfBirth;
public Artist(String name, int yearOfBirth) {
this.name = name;
this.yearOfBirth = yearOfBirth;
}
public String getName() {
// Kirjoita tämän metodin toteutus
}
public void setName(String name) {
// Kirjoita tämän metodin toteutus
}
public int getYearOfBirth() {
// Kirjoita tämän metodin toteutus
}
public void setYearOfBirth(int yearOfBirth) {
// Kirjoita tämän metodin toteutus
}
@Override
public String toString() {
return this.name;
}
}
```
HUOM! Ratkaisusi ei saa kysyä käyttäjältä syötteitä eikä tulostaa mitään. Koodin testaa erillinen tarkastin.
```
Example output:
= Suoritetaan koodi =
Artist rick = new Artist("Rick", 1966);
System.out.println(rick.getName());
System.out.println(rick.getYearOfBirth());
rick.setName("Rick Astley");
System.out.println(rick.getName());
= Ohjelman tuloste =
Rick
1966
Rick Astley
```
------------------
```
public class Artist {
private String name;
private int yearOfBirth;
public Artist(String name, int yearOfBirth) {
this.name = name;
this.yearOfBirth = yearOfBirth;
}
public void setName(String name) {
this.name = name;
}
public void setYearOfBirth(int yearOfBirth) {
this.yearOfBirth = yearOfBirth;
}
public String getName() {
return this.name;
}
public int getYearOfBirth() {
return this.yearOfBirth;
}
@Override
public String toString() {
return this.name;
}
}
```

+ 162
- 0
10_classes-and-objects/5_Artist_Song.md View File

@ -0,0 +1,162 @@
Tässä tehtävässä tarkoituksena on hyödyntää edellisessä tehtävässä toteutettua Artist-luokkaa toisen luokan kanssa. Musiikkikappaleeseen on siis tarkoitus tallentaa tieto siitä, minkä artistin kappale se on. Tieto tallennetaan asettamalla Artist-olio talteen Song-olion oliomuuttujaan.
Kirjoita uusi luokka nimeltä Song. Song-luokassa tulee olla seuraavat oliomuuttujat ja -metodit:
Luokka Song
- oliomuuttujat:
- private String title
- private Artist artist
- private int year (kappaleen julkaisuvuosi)
- private int length (kappaleen kesto sekunteina)
- konstruktorit:
- public Song()
- Huom! Luokalle ei ole pakko toteuttaa konstruktoria, mutta jos toteutat sellaisen, konstruktorissa ei saa olla parametrimuuttujia.
- julkiset metodit:
- getTitle
- setTitle
- getArtist
- setArtist
- getYear
- setYear
- getLength
- setLength
- toString
Getterien ja setterien automaattiseen generointiin voit käyttää myös Eclipsen koodigeneraattoria.
Generaattori: https://www.youtube.com/results?search_query=eclipse+generate+getters+and+setters
**toString-metodi**
Song-luokan toString-metodin tulee palauttaa "KAPPALEEN_NIMI by ARTISTIN_NIMI". Esimerkiksi:
```
"Hooked on a Feeling by David Hasselhoff"
```
Jos Song-oliolle ei ole asetettu artistia tai artistilla ei ole nimeä, toString-metodin tulee palauttaa vain kappaleen nimi, esimerkiksi:
```
"Hooked on a Feeling"
```
Artist-luokan toteutuksen on oltava täsmälleen samanlainen kuin edellisessä tehtävässä. Sinun ei tarvitse palauttaa omaa pääohjelmaa ja kirjoittamasi luokat eivät saa tulostaa mitään.
```
Example output:
= Suoritetaan ohjelma =
Artist artist = new Artist("Rick Astley", 1966);
System.out.println(artist);
Song song = new Song();
song.setTitle("Never Gonna Give You Up");
song.setYear(1987);
song.setLength(215);
System.out.println(song);
song.setArtist(artist);
System.out.println(song);
= Ohjelman tuloste =
Rick Astley
Never Gonna Give You Up
Never Gonna Give You Up by Rick Astley
```
------------------
```
// Artist.java
public class Artist {
private String name;
private int yearOfBirth;
public Artist(String name, int yearOfBirth) {
this.name = name;
this.yearOfBirth = yearOfBirth;
}
public void setName(String name) {
this.name = name;
}
public void setYearOfBirth(int yearOfBirth) {
this.yearOfBirth = yearOfBirth;
}
public String getName() {
return this.name;
}
public int getYearOfBirth() {
return this.yearOfBirth;
}
@Override
public String toString() {
return this.name;
}
}
```
------------------
```
// Song.java
public class Song {
private String title;
private Artist artist;
private int year;
private int length;
public String getTitle() {
return this.title;
}
public void setTitle(String title) {
this.title = title;
}
public Artist getArtist() {
return this.artist;
}
public void setArtist(Artist artist) {
this.artist = artist;
}
public int getYear() {
return this.year;
}
public void setYear(int year) {
this.year = year;
//return this.year;
}
public int getLength() {
return this.length;
}
public void setLength(int length) {
this.length = length;
//return this.length;
}
public String toString() {
if (this.artist != null) {
return this.title + " by " + this.artist;
} else {
return this.title;
}
}
}
```

+ 127
- 0
10_classes-and-objects/6_Playlist.md View File

@ -0,0 +1,127 @@
Tässä harjoituksessa hyödynnetään edellisessä harjoituksessa kirjoittamiasi Artist- ja Song-luokkia. Tehtäväsi on hyödyntää edellä mainittuja luokkia ja kirjoittaa uusi Playlist-niminen luokka. Kirjoita Playlist-luokka omaan tiedostoonsa. Artist- ja Song-luokkia sinun ei tarvitse palauttaa, ne löytyvät Viopesta valmiina.
Playlist-luokassa tulee olla seuraavat instanssimuuttujat, konstruktorit ja metodit:
- yksityiset instanssimuuttujat:
- ArrayList<Song> songs
- julkiset konstruktorit:
- Playlist()
luo soittolistalle uusi songs-lista täällä
- julkiset metodit:
- void addSong(Song song)
lisää annetun kappaleen songs-listalle viimeiseksi
- Song getSong(int index)
palauttaa listalta kohdassa index olevan kappaleen, tai null jos kohdassa ei ole kappaletta. Vertaa tässä metodissa annettua indeksiä songs-listan pituuteen ennen kuin kutsut listan get-metodia!
- int getTotalLength()
laskee soittolistan kappaleiden yhteiskeston sekunteina ja palauttaa tuloksen
- String toString()
Playlist-luokan toString-metodin tulee palauttaa merkkijono, jossa kutakin kappaletta kohden on yksi rivi. Rivin tulee alkaa numerolla ja kaksoispisteellä, ja niiden jälkeen tulee olla kappaleen toString-metodin palauttama merkkijonoesitys. Huomaa, että toString ei saa tulostaa mitään, vaan sen tulee palauttaa muodostettu merkkijono. Esimerkiksi:
```
1: Never Gonna Give You Up by Rick Astley
2: Hooked on a Feeling by David Hasselhoff
```
Tässä harjoituksessa sinun ei tarvitse palauttaa omaa pääohjelmaa ja tehtävänannossa vaaditut metodit eivät saa tulostaa mitään. Oman pääohjelman kirjoittaminen luokan testaamiseksi on kuitenkin erittäin suositeltavaa.
Tässä tehtävässä esiintyvän kappaleiden pituuksien yhteenlaskun hahmottamiseksi on tehty videotallenne, jossa ratkaistaan vastaavaa ongelmaa pelaajien pituuksien yhteenlaskun muodossa. Vastaavasti toString-metodin toteutuksessa voit hyödyntää videotallennetta jossa käydään läpi listalla olevia merkkijonoja, jotka yhdistetään toistorakenteessa yhdeksi.
```
Example output:
= Suoritetaan ohjelma =
Playlist playlist = new Playlist();
Artist artist = new Artist("Rick Astley", 1966);
Song song = new Song();
song.setTitle("Never Gonna Give You Up");
song.setYear(1987);
song.setLength(215);
song.setArtist(artist);
playlist.addSong(song);
System.out.println(playlist);
System.out.println(playlist.getTotalLength());
Artist artist2 = new Artist("David Hasselhoff", 1952);
Song song2 = new Song();
song2.setTitle("Hooked on a Feeling");
song2.setYear(1997);
song2.setLength(211);
song2.setArtist(artist2);
playlist.addSong(song2);
System.out.println(playlist);
System.out.println(playlist.getTotalLength());
= Ohjelman tuloste =
1: Never Gonna Give You Up by Rick Astley
215
1: Never Gonna Give You Up by Rick Astley
2: Hooked on a Feeling by David Hasselhoff
426
```
------------------
```
import java.util.ArrayList;
public class Playlist {
private ArrayList<Song> songs = new ArrayList<Song>();
public Playlist() {
// luo soittolistalle uusi songs-lista täällä
this.songs = songs;
}
public void addSong(Song song) {
// lisää annetun kappaleen songs-listalle viimeiseksi
this.songs.add(song);
}
public Song getSong(int index) {
// palauttaa listalta kohdassa index olevan kappaleen, tai null jos kohdassa ei ole kappaletta.
// Vertaa tässä metodissa annettua indeksiä songs-listan pituuteen ennen kuin kutsut listan get-metodia!
if (index < this.songs.size() - 1) {
return this.songs.get(index);
} else {
return null;
}
}
public int getTotalLength() {
// laskee soittolistan kappaleiden yhteiskeston sekunteina ja palauttaa tuloksen
int l = 0;
for (int i = 0; i < this.songs.size(); i++) {
l += this.songs.get(i).getLength();
}
return l;
}
@Override
public String toString() {
// Playlist-luokan toString-metodin tulee palauttaa merkkijono, jossa kutakin kappaletta kohden on yksi rivi.
// Rivin tulee alkaa numerolla ja kaksoispisteellä, ja niiden jälkeen tulee olla kappaleen toString-metodin
// palauttama merkkijonoesitys. Huomaa, että toString ei saa tulostaa mitään, vaan sen tulee palauttaa
// muodostettu merkkijono. Esimerkiksi:
// 1: Never Gonna Give You Up by Rick Astley
// 2: Hooked on a Feeling by David Hasselhoff
String strConst = "";
for (int i = 0; i < this.songs.size(); i++) {
strConst += (i + 1) + ": " + this.songs.get(i) + "\n";
}
return strConst;
}
}
```

+ 320
- 0
10_classes-and-objects/7_KirjaOhjelma.md View File

@ -0,0 +1,320 @@
Tee luokka Kirja. Kirja-luokalla on ominaisuudet nimi, isbn, hinta ja julkaisuvuosi. Tee luokkaan set-, get- ja toString-metodit, parametriton konstruktori ja parametrillinen konstruktori. Käytä metodien tekemiseen Eclipsen Source valikosta löytyviä Generate toimintoja.
Tee ohjelmaluokka KirjaOhjelma, jossa tehdään kaksi olioita. Ensimmäinen olio tehdään parametrillisella konstruktorilla ja näytetään toString-metodilla. Toinen olio tehdään parametrittomalla konstruktorilla. Tiedot asetetaan set-metodeilla ja näytetään get-metodeilla.
```
Example output:
Anna nimi: 97 Things Every Java Programmer Should Know
Anna isbn: ei tietoa
Anna hinta: 26,80
Anna julkaisuvuosi: 2020
Kirja [nimi=97 Things Every Java Programmer Should Know, isbn=ei tietoa, hinta=26.8, vuosi=2020]
Nimi: 97 Things Every Java Programmer Should Know
Isbn: ei tietoa
Hinta: 26,80
Julkaisuvuosi: 2020
```
------------------
```
// Kirja.java
public class Kirja {
private String nimi, isbn;
private double hinta;
private int julkaisuvuosi;
public void setNimi(String nimi) {
this.nimi = nimi;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
public void setHinta(double hinta) {
this.hinta = hinta;
}
public void setJulkaisuvuosi(int julkaisuvuosi) {
this.julkaisuvuosi = julkaisuvuosi;
}
public String getNimi() {
return this.nimi;
}
public String getIsbn() {
return this.isbn;
}
public double getHinta() {
return this.hinta;
}
public int getJulkaisuvuosi() {
return this.julkaisuvuosi;
}
// Parametriton konstruktori
public Kirja() {
}
// Parametrillinen konstruktori
public Kirja(String nimi, String isbn, double hinta, int julkaisuvuosi) {
this.setNimi(nimi);
this.setIsbn(isbn);
this.setHinta(hinta);
this.setJulkaisuvuosi(julkaisuvuosi);
}
@Override
public String toString() {
return "Kirja [" +
"nimi=" + this.nimi +
", isbn=" + this.isbn +
", hinta=" + this.hinta +
", vuosi=" + this.julkaisuvuosi +
"]";
}
}
/*
@Override
public String toString() {
ArrayList<Object> kirjaData = new ArrayList<Object>(Arrays.asList(
"nimi=" + this.getName(),
"isbn=" + this.getISBN(),
"hinta=" + this.getPrice(),
"julkaisuvuosi=" + this.getYear()
));
ArrayList<Object> kirjaData = new ArrayList<Object>(Arrays.asList(
this.getName(),
this.getISBN(),
this.getPrice(),
this.getYear()
));
return kirjaData.toString();
}
*/
```
------------------
```
// KirjaOhjelma.java
import java.text.DecimalFormat;
import java.util.InputMismatchException;
import java.util.Scanner;
public class KirjaOhjelma {
private static Kirja kirja = new Kirja();
private String kirjaData;
public static void main() {
// Luodaan olio: Parametriton KirjaOhjelma
// Täällä saamme datan, jota voimme käsitellä parametrillisessa
// oliossa.
KirjaOhjelma kirjaJavaObject_1 = new KirjaOhjelma();
// Luodaan olio: Parametrillinen KirjaOhjelma
KirjaOhjelma kirjaJavaObject_2 = new KirjaOhjelma(
kirja.getNimi(),
kirja.getIsbn(),
kirja.getHinta(),
kirja.getJulkaisuvuosi()
);
System.out.println(kirja);
System.out.println(kirjaJavaObject_2);
}
// Parametrillinen konstruktori
public KirjaOhjelma(String nimi, String isbn, double hinta, int julkaisuvuosi) {
DecimalFormat r2 = new DecimalFormat(".00");
this.kirjaData = String.format(
"Nimi: %s\nIsbn: %s\nHinta: %s\nJulkaisuvuosi: %s\n",
nimi,
isbn,
r2.format(hinta),
julkaisuvuosi
);
}
@Override
public String toString() {
return this.kirjaData;
}
// Parametriton konstruktori
public KirjaOhjelma() {
Scanner syote = new Scanner(System.in);
System.out.print("Anna nimi: ");
kirja.setNimi(syote.nextLine());
System.out.print("Anna isbn: ");
kirja.setIsbn(syote.nextLine());
try {
System.out.print("Anna hinta: ");
kirja.setHinta(syote.nextDouble());
} catch (InputMismatchException e) {
System.err.println("Syöttämäsi hinta ei ole kelvollinen luku");
System.exit(1);
}
try {
System.out.print("Anna julkaisuvuosi: ");
kirja.setJulkaisuvuosi(syote.nextInt());
} catch (InputMismatchException e) {
System.err.println("Syöttämäsi vuosi ei ole kelvollinen luku");
System.exit(1);
}
}
}
//System.out.println(kirja);
//ArrayList<Object> kirjaDataArray = new ArrayList<Object>();
//kirjaDataArray.add(kirja.getNimi());
//kirjaDataArray.add("nimi=" + kirja.getNimi());
//kirjaDataArray.add(kirja.getIsbn());
//kirjaDataArray.add("isbn=" + kirja.getIsbn());
//kirjaDataArray.add(kirja.getHinta());
//kirjaDataArray.add("hinta=" + kirja.getHinta());
//kirjaDataArray.add(kirja.getJulkaisuvuosi());
//kirjaDataArray.add("vuosi=" + kirja.getJulkaisuvuosi());
//System.out.println("Kirja: " + kirjaDataArray.toString());
//this.kirjaData = kirjaDataArray;
/*
System.out.printf("Kirja: " +
"nimi=" + kirjaDataArray.get(0).toString(),
"isbn=" + kirjaDataArray.get(1).toString(),
"hinta=" + kirjaDataArray.get(2).toString(),
"vuosi=" + kirjaDataArray.get(3).toString()
);
*/
// Parametriton - Kirja
/*Kirja javaKirja = new Kirja();
javaKirja.setNimi("97 Things Every Java Programmer Should Know");
javaKirja.setIsbn("ei tietoa");
javaKirja.setHinta(26.80);
javaKirja.setJulkaisuvuosi(2020);
// Parametrillinen -Kirja
javaKirja = new Kirja(
"97 Things Every Java Programmer Should Know",
"ei tietoa",
26.80,
2020
);*/
// Parametrillinen - KirjaOhjelma
//this.javaKirja = new Kirja();
/*
// Parametrillinen konstruktori
public KirjaOhjelma(String nimi, String isbn, double hinta, int julkaisuvuosi) {
DecimalFormat r2 = new DecimalFormat(".00");
this.kirjaData = String.format(
"Nimi: %s\nIsbn: %s\nHinta: %s\nJulkaisuvuosi: %s\n",
nimi,
isbn,
r2.format(hinta),
julkaisuvuosi
);
}*/
/*
// Parametriton konstruktori
public KirjaOhjelma() {
Scanner syote = new Scanner(System.in);
ArrayList<String> kirjaDataArray = new ArrayList<String>();
Kirja kirjaInput = new Kirja();
System.out.print("Anna nimi: ");
kirjaInput.setNimi(syote.nextLine());
kirjaDataArray.add("nimi=" + kirjaInput.getNimi());
System.out.print("Anna isbn: ");
kirjaInput.setIsbn(syote.nextLine());
kirjaDataArray.add("isbn=" + kirjaInput.getIsbn());
System.out.print("Anna hinta: ");
kirjaInput.setHinta(syote.nextDouble());
kirjaDataArray.add("hinta=" + kirjaInput.getHinta());
System.out.print("Anna julkaisuvuosi: ");
kirjaInput.setJulkaisuvuosi(syote.nextInt());
kirjaDataArray.add("julkaisuvuosi=" + kirjaInput.getJulkaisuvuosi());
this.kirjaData = kirjaDataArray;
}
*/
/*
@Override
public String toString() {
//if (this.kirjaData instanceof String) {
return this.kirjaData.toString();
//} else {
// return null;
//}
}*/
//private String kirjaDataStr;
//private ArrayList<String> kirjaData = new ArrayList<String>();
/*
@Override
public String toString() {
DecimalFormat r2 = new DecimalFormat(".00");
String t = String.format(
"Nimi: %s\nIsbn: %s\nHinta: %s\nJulkaisuvuosi: %s\n",
this.kirjaInput.getName(),
this.kirjaInput.getISBN(),
r2.format(this.kirjaInput.getPrice()),
this.kirjaInput.getYear()
);
return String.format("%s\n\n%s", this.kirjaInput.toString(), t);
//return this.kirjaInput.toString();
}*/
//this.kirjaInput = kirjaUserInput;
/*this.kirjaData = new ArrayList<Object>(Arrays.asList(
"nimi=" + this.kirjaInput.getName(),
"isbn=" + this.kirjaInput.getISBN(),
"hinta=" + this.kirjaInput.getPrice(),
"julkaisuvuosi=" + this.kirjaInput.getYear()
));*/
```

+ 188
- 0
10_classes-and-objects/8_AsuntoOhjelma.md View File

@ -0,0 +1,188 @@
Tee luokka Tee luokka Asunto, jolla on attribuutit tyyppi (String), osoite (String), pinta-ala (double), hinta (double) ja kuvaus(String). Tee luokkaan parametriton ja parametrillinen konstruktori, set- ja get-metodit ja toString-metodi. Tee ohjelmaluokka AsuntoOhjelma, jossa tehdään yksi olio.
```
Example output:
Anna asunnon tyyppi: Kerrostalo
Anna osoite: Ivalontie 12, 99800 Inari
Anna pinta-ala: 72,0
Anna hinta: 72000,00
Anna kuvaus: valon keskustassa katutasossa 72 m2:n liikehuoneisto
Tyyppi: Kerrostalo
Osoite: Ivalontie 12, 99800 Inari
Pinta-ala: 72,00
Hinta: 72000,00 euroa
Kuvaus: valon keskustassa katutasossa 72 m2:n liikehuoneisto
```
------------------
```
// Asunto.java
import java.text.DecimalFormat;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Asunto {
private String tyyppi, osoite, kuvaus;
private double pinta_ala, hinta;
// set-metodit
public void setTyyppi(String tyyppi) {
this.tyyppi = tyyppi;
}
public void setOsoite(String osoite) {
this.osoite = osoite;
}
public void setKuvaus(String kuvaus) {
this.kuvaus = kuvaus;
}
public void setPinta_ala(double pinta_ala) {
this.pinta_ala = pinta_ala;
}
public void setHinta(double hinta) {
this.hinta = hinta;
}
// get-metodit
public String getTyyppi() {
return tyyppi;
}
public String getOsoite() {
return osoite;
}
public String getKuvaus() {
return kuvaus;
}
public double getPinta_ala() {
return pinta_ala;
}
public double getHinta() {
return hinta;
}
// Parametrillinen konstruktori
public Asunto(String tyyppi, String osoite, double pinta_ala, double hinta, String kuvaus){
this.setTyyppi(tyyppi);
this.setOsoite(osoite);
this.setPinta_ala(pinta_ala);
this.setHinta(hinta);
this.setKuvaus(kuvaus);
}
// Parametriton konstruktori
public Asunto() {
Scanner syote = new Scanner(System.in);
System.out.print("Anna asunnon tyyppi: ");
this.setTyyppi(syote.nextLine());
System.out.print("Anna osoite: ");
this.setOsoite(syote.nextLine());
try {
System.out.print("Anna pinta-ala: ");
this.setPinta_ala(syote.nextDouble());
} catch (InputMismatchException e) {
System.err.println("Syöttämäsi pinta-ala ei ole kelvollinen luku");
System.exit(1);
}
try {
System.out.print("Anna hinta: ");
this.setHinta(syote.nextDouble());
} catch (InputMismatchException e) {
System.err.println("Syöttämäsi hinta ei ole kelvollinen luku");
System.exit(1);
}
// Consume newline
syote.nextLine();
System.out.print("Anna kuvaus: ");
this.setKuvaus(syote.nextLine());
}
@Override
public String toString() {
DecimalFormat r2 = new DecimalFormat(".00");
return String.format(
"Tyyppi: %s\nOsoite: %s\nPinta-ala: %s\nHinta: %s\nKuvaus: %s",
this.getTyyppi(),
this.getOsoite(),
r2.format(this.getPinta_ala()),
r2.format(this.getHinta()) + " euroa",
this.getKuvaus()
);
}
}
```
------------------
```
// AsuntoOhjelma.java
public class Song {
private String title;
private Artist artist;
private int year;
private int length;
public String getTitle() {
return this.title;
}
public void setTitle(String title) {
this.title = title;
}
public Artist getArtist() {
return this.artist;
}
public void setArtist(Artist artist) {
this.artist = artist;
}
public int getYear() {
return this.year;
}
public void setYear(int year) {
this.year = year;
}
public int getLength() {
return this.length;
}
public void setLength(int length) {
this.length = length;
//return this.length;
}
public String toString() {
if (this.artist != null) {
return this.title + " by " + this.artist;
} else {
return this.title;
}
}
}
```

+ 110
- 0
10_classes-and-objects/9_RemonttiOhjelma.md View File

@ -0,0 +1,110 @@
Tee luokka Remontti, jolla on attribuutit vuosi (int), kuvaus (String). Tee luokkaan parametriton konstruktori, joka asettaa vuodeksi nykyisen vuoden. Nykyisen vuoden saat käyttämällä LocalDate luokkaa. Tee lisäksi set- ja get-metodit ja toString-metodi. setVuosi metodin tarkastaa, ettei remontin vuosi ole nykyistä vuotta suurempi. Metodi palauttaa true, jos vuosi pystyttiin asettamaan eli sen on nykyinen tai sitä aiempi vuosi muuten metodi palauttaa false eikä aseta vuodeksi annettua vuotta. Tee ohjelmaluokka RemonttiOhjelma, jossa tehdään yksi olio.
Kun palautat ratkaisun Viopeen, muista laittaa alkuun kaikki import komennot.
Jos ohjelman suoritus onnistuu, sen täytyy toimia seuraavasti:
```
Anna vuosi: 2019
Anna kuvaus: Putkiremontti
Vuonna 2019 tehtiin remontti Putkiremontti
```
Jos annettu päivämäärä on tulevaisuudessa, ohjelma toimii seuraavasti:
```
Anna vuosi: 2030
Vuosi ei voi olla tulevaisuudessa
```
```
Example output:
Anna vuosi: 2030
Vuosi ei voi olla tulevaisuudessa
```
------------------
```
// Remontti.java
import java.time.LocalDate;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Remontti {
private int vuosi;
private String kuvaus;
// set-metodit
public boolean setVuosi(int vuosi) {
LocalDate nykyHetki = LocalDate.now();
if (vuosi > nykyHetki.getYear()) {
System.out.println("Vuosi ei voi olla tulevaisuudessa");
return false;
} else {
this.vuosi = vuosi;
return true;
}
}
public void setKuvaus(String kuvaus) {
this.kuvaus = kuvaus;
}
// get-metodit
public int getVuosi() {
return vuosi;
}
public String getKuvaus() {
return kuvaus;
}
public Remontti() {
Scanner syote = new Scanner(System.in);
System.out.print("Anna vuosi: ");
try {
if (!this.setVuosi(syote.nextInt())) {
System.exit(0);
}
} catch (InputMismatchException e) {
System.err.println("Syöte ei ole kokonaisluku");
System.exit(1);
}
// Consume previous newline
syote.nextLine();
System.out.print("Anna kuvaus: ");
this.setKuvaus(syote.nextLine());
}
@Override
public String toString() {
return String.format(
"Vuonna %d tehtiin remontti %s",
this.getVuosi(),
this.getKuvaus()
);
}
}
```
------------------
```
// RemonttiOhjelma.java
public class RemonttiOhjelma {
public static void main() {
Remontti remppa = new Remontti();
System.out.println(remppa);
}
}
```

+ 19
- 0
1_basics/1_TerveMaailma.md View File

@ -0,0 +1,19 @@
Kirjoita luokka TerveMaailma ja siihen main-metodi, jossa tulostat ruudulle tekstin "Terve maailma!".
```
Example output:
Terve maailma!
```
--------------------
**TerveMaailma.java**
```
public class TerveMaailma {
public static void main(String[] args) {
System.out.println("Terve maailma!");
}
}
```

+ 38
- 0
1_basics/2_HeiEtunimi.md View File

@ -0,0 +1,38 @@
Kirjoita luokka HeiEtunimi. Toteuta luokkaan main-metodi, jossa kysytään ensin käyttäjän etunimi, ja sen jälkeen tervehditään käyttäjää nimeltä. Tarvitset tehtävässä Javan Scanner-luokkaa syötteen lukemiseksi. Voit käyttää tehtävän ratkaisemiseksi alla olevaa pohjaa:
```
import java.util.Scanner;
public class HeiEtunimi {
public static void main(String[] args) {
// Kirjoita ratkaisusi tänne
}
}
```
```
Example output:
Syötä etunimi: Maija
Hei Maija!
```
----------
**HeiEtunimi.java**
```
import java.util.Scanner;
public class HeiEtunimi {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
System.out.print("Syötä etunimi: ");
String nimi = syote.next();
System.out.printf("Hei %s!", nimi);
}
}
```

+ 32
- 0
1_basics/3_Puoluetuki.md View File

@ -0,0 +1,32 @@
Tee ohjelma Puoluetuki, joka laskee puolueen puoluetuen määrän vuodessa. Yhden kansanedustajan puoluetuki on 148 175 euroa.
```
Example output:
Anna kansanedustajien lukumäärä: 10
Puoluetuen määrä on 1481750 euroa
```
----------
**Puoluetuki.java**
```
import java.util.Scanner;
public class Puoluetuki {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int puoluetuki_maara = 148175;
System.out.print("Anna kansanedustajien lukumäärä: ");
int edustaja_lkm = syote.nextInt();
int puoluetuki_yhteensa = edustaja_lkm * puoluetuki_maara;
System.out.println("Puoluetuen määrä on " + puoluetuki_yhteensa + " euroa");
}
}
```

+ 38
- 0
1_basics/4_Bitcoin.md View File

@ -0,0 +1,38 @@
Tee ohjelma Bitcoin, joka laskee Bitcoinin tuoton vuodessa, jos tuottoennusteena pidetään vuoden 2017 tulosta. Vuonna 2017 Bitcoiniin sijoitetun rahan arvo 15,06 kertaisti itsensä. Ota huomioon, että investoitua rahasummaa ei lasketa sijoituksen tuottoon mukaan.
Huom! Tässä tehtävässä et saa pyöristää etkä muotoilla lopputulosta, vaan double-arvo tulee tulostaa sellaisenaan.
Huom! Tehtävässä kysytään sijoituksen tuottoa, eli sijoituksen loppuarvosta vähennetään sijoitettu alkupääoma.
```
Example output:
Anna Bitcoineihin investoidun rahan määrä:
150
Bitcoin tuotti vuodessa 2109.0 euroa
```
----------
**Bitcoin.java**
```
import java.util.Scanner;
public class Bitcoin {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
double bitcoin_kerroin_2017 = 15.06;
System.out.print("Anna Bitcoineihin investoidun rahan määrä: ");
double bitcoin_sijoitus = syote.nextDouble();
// Tuotto, josta vähennetään sijoitettu alkupääoma
double bitcoin_tuotto = (bitcoin_sijoitus * bitcoin_kerroin_2017) - bitcoin_sijoitus;
System.out.println("Bitcoin tuotti vuodessa " + bitcoin_tuotto + " euroa");
}
}
```

+ 53
- 0
1_basics/5_Pikavippi.md View File

@ -0,0 +1,53 @@
Tee ohjelma Pikavippi, joka kertoo paljonko lainatusta rahasta pitää maksaa. Ohjelmalle kerrotaan yhtiön laittama korko ja vuosimäärä, jonka jälkeen maksuja takaisinmaksu vasta tehtäisiin – yksi tai kaksi vuotta. Ohjelmalle annetaan myös korkoprosentti: Nordax pankki tarjoaa pikavippejä 41 prosentin korolla vuodeksi ja Viikinkilaina 37 prosentin korolla kahdeksi vuodeksi.
Käytännössä vuoden lainakoroksi annetaan aina 41 ja kahden vuoden koroksi 37 prosenttia. Tässä tehtävässä ei huomioida korkoa korolle -ilmiötä tai lainan maksamista takaisin osissa.
Huom 1! Tässä tehtävässä et saa pyöristää etkä muotoilla lopputulosta, vaan double-arvo tulee tulostaa sellaisenaan.
Huom 2! Tehtävä ei laske oikein korkoa korolle ilmiötä kahden vuoden tapauksessa, vaan ainoastaan kerrotaan ensimmäisen vuoden korko kahdella. Ohjelmaan ei tule tehdä if-rakenteita.
```
Example output:
Anna pikavipin määrä euroissa: 500
Moneksiko vuodeksi raha halutaan (1 tai 2): 1
Lainakorko kahdesta yleisestä (41% tai 37%): 41
Lainatut rahat maksavat eli korko 205.0
```
----------
**Pikavippi.java**
```
import java.util.Scanner;
public class Pikavippi {
public static void main(String[] args) {
// Voitaisiin käyttää myös useampaa Scanneria
Scanner syote = new Scanner(System.in);
/* Näitä voitaisiin käyttää, jos ohjelmaan toteutettaisiin esimerkiksi ehtolauseita.
// Vuoden korko, Kahden vuoden korko
double vuosikorko_nordax = 41, vuosikorko_viikinkilaina = 37;
*/
// Tulosteissa ja niiden tarkistamisessa tarvittaisiin ehtolauseita ja virhetilanteiden (virheellisten syötteiden) hallintaa.
System.out.print("Anna pikavipin määrä euroissa: ");
double pikavippi_euro = syote.nextDouble();
System.out.print("Moneksiko vuodeksi raha halutaan (1 tai 2): ");
double pikavippi_vuosi = syote.nextInt();
System.out.print("Lainakorko kahdesta yleisestä (41% tai 37%): ");
double pikavippi_korko = syote.nextInt();
double lainaraha_hinta = (pikavippi_euro * (pikavippi_korko/100)) * pikavippi_vuosi;
System.out.printf("Lainatut rahat maksavat eli korko %s", lainaraha_hinta);
}
}
```

+ 43
- 0
1_basics/6_Maalaus.md View File

@ -0,0 +1,43 @@
Tee ohjelma Maalaus, joka kertoo, paljonko maalia on ostettava. Ohjelma kysyy huoneen leveyden, pituuden ja korkeuden sekä paljonko litralla maalia saadaan maalattua. Ohjelma kertoo tämän jälkeen maalin tarpeen litroina. Muotoile vastaus kahdella desimaalilla.
Esimerkiksi huoneen leveys on 3.2 metriä, pituus on 3.0 metriä ja korkeus 2.5 metriä. Litralla maalia saadaan maalattua 7.0 neliötä. Maalia tarvitaan koko huoneen maalaamiseen 4.43 l ((leveys + leveys + pituus + pituus) * korkeus / litralla).
Huom! Muista muotoilla tulos käyttäen java.text.DecimalFormat-luokkaa ja kahden desimaalin tarkkuutta.
```
Example output:
Anna huoneen leveys, pituus ja korkeus: 3,40 3,00 2,50
Paljonko litralla saadaan maalattua neliöitä: 5
Maalin tarve on 6,40 litraa
```
----------
**Maalaus.java**
```
import java.util.Scanner;
import java.text.DecimalFormat;
public class Maalaus {
public static void main(String[] args) {
DecimalFormat round_2 = new DecimalFormat("0.00");
Scanner syote = new Scanner(System.in);
System.out.print("Anna huoneen leveys, pituus ja korkeus: ");
double leveys = syote.nextDouble();
double pituus = syote.nextDouble();
double korkeus = syote.nextDouble();
double m2_yhteensa = (2 * leveys + 2 * pituus) * korkeus;
System.out.print("Paljonko litralla saadaan maalattua neliöitä: ");
double maali_riittavyys_m2_litra = syote.nextDouble();
double maali_riittavyys = m2_yhteensa / maali_riittavyys_m2_litra;
System.out.println("Maalin tarve on " + round_2.format(maali_riittavyys) + " litraa");
}
}
```

+ 35
- 0
1_basics/7_Cooper.md View File

@ -0,0 +1,35 @@
Tee ohjelma Cooper, joka kysyy Cooperissa juostun matkan. Ohjelma kertoo, montako kokonaista 400 metrin kierrosta juostiin. Kierroksien määrän lasketaan matka / 400.
```
Example output:
Anna juostu matka: 2987
Kokonaisia 400 metrin kierroksia oli 7
```
----------
**Cooper.java**
```
import java.util.Scanner;
public class Cooper {
public static void main(String[] args) {
double kierros_pituus = 400;
Scanner syote = new Scanner(System.in);
System.out.print("Anna juostu matka: ");
double juostu_matka = syote.nextDouble();
double kierrokset_yhteensa = Math.floor(juostu_matka / kierros_pituus);
System.out.printf(
"Kokonaisia %s metrin kierroksia oli %s",
(int)kierros_pituus,
(int)kierrokset_yhteensa
);
}
}
```

+ 41
- 0
1_basics/8_Juhlat.md View File

@ -0,0 +1,41 @@
Tee ohjelma Juhlat, millä voidaan laskea, montako kuohuviinipulloa juhliin tarvitsee hankkia. Yhdestä pullosta saa 7 lasillista. Ohjelma kysyy vieraiden määrän ja kertoo
- tarvittavien kuohuviinipullojen määrän kokonaislukuna (vinkkinä: etsi tietoa ceil-käskystä)
- montako lasia jää yli viimeisestä pullosta
```
Example output:
Anna juhliin tulevien aikuisten määrä: 23
Pulloja tarvitaan 4 kappaletta
Viimeisestä pullosta jää 5 lasia
```
----------
**Juhlat.java**
```
import java.util.Scanner;
public class Juhlat {
public static void main(String[] args) {
int lasilliset_per_pullo = 7;
Scanner syote = new Scanner(System.in);
System.out.print("Anna juhliin tulevien aikuisten määrä: ");
double vieraat_lkm = syote.nextInt();
double pullot_desim = vieraat_lkm / lasilliset_per_pullo;
int pullot_lkm = (int)Math.ceil(pullot_desim);
System.out.println("Pulloja tarvitaan " + pullot_lkm + " kappaletta");
int ylim_lasilliset_lkm = (int)Math.round(((double)pullot_lkm - pullot_desim) * lasilliset_per_pullo);
System.out.println("Viimeisestä pullosta jää " + ylim_lasilliset_lkm + " lasia");
}
}
```

+ 44
- 0
1_basics/9_LukujenSumma.md View File

@ -0,0 +1,44 @@
Koodin selkeä muotoilu helpottaa sen luettavuutta ja ymmärrettävyyttä. Eri yrityksillä ja yhteisöillä on omia muotoilusääntöjään (Google, Twitter, Android...) mutta yhteistä niissä on, että koodin selkeyttä edistetään yhtenäisten sisennysten, nimeämiskäytäntöjen ja tyhjän tilan käytöllä.
Eclipsessä on kätevä näppäinyhdistelmä Ctrl + ⇧ + F (Mac: ⌘ + ⇧ + F), jolla avoinna olevan Java-tiedoston tai valitut rivit saa muotoiltua Eclipsen muotoilusääntöjen mukaisesti. Eclipsen saa myös muotoilemaan koodin automaattisesti aina tallennettaessa tiedostoa.
Alla on esitetty luokka LukujenSumma, jonka muotoilut eivät noudata hyviä käytäntöjä. Muotoilun puutteen vuoksi myös koodissa oleva selvä syntaksivirhe voi olla vaikea havaita.
Tässä tehtävässä sinun tulee kopioida alla esitetty luokka itsellesi, muotoilla se Eclipsen muotoilusääntöjen mukaisesti, korjata syntaksivirhe ja palauttaa korjattu ja muotoiltu versio Viopeen.
Sinun ei tarvitse muuttaa ohjelman toiminnallisuutta lainkaan.
```
import java.util.Scanner;
public class LukujenSumma {
public static void main(String[] args) {
Scanner lukija = new Scanner(System.in);
System.out.print("Kirjoita kaksi kokonaislukua: ");
int eka=lukija.nextInt();
toka=lukija.nextInt();
System.out.println("Lukujen summa on "+(eka+toka));
lukija.close();}}
```
----------
**LukujenSumma.java**
```
import java.util.Scanner;
public class LukujenSumma {
public static void main(String[] args) {
Scanner lukija = new Scanner(System.in);
System.out.print("Kirjoita kaksi kokonaislukua: ");
int eka = lukija.nextInt();
int toka = lukija.nextInt();
System.out.println("Lukujen summa on " + (eka + toka) );
lukija.close();
}
}
```

+ 30
- 0
2_conditionals/1_Ylinopeus.md View File

@ -0,0 +1,30 @@
Tee ohjelma Ylinopeus.java, joka kysyy käyttäjältä kokonaisluvun ja tulostaa merkkijonon "Ylinopeussakko!" jos luku on suurempi kuin 120.
Jos annettu luku on 120 tai vähemmän, ohjelmasi ei tule tulostaa mitään.
```
Example output:
Kerro nopeus: 90
```
--------------------
**Ylinopeus.java**
```
import java.util.Scanner;
public class Ylinopeus {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
System.out.print("Kerro nopeus: ");
double nopeus = syote.nextInt();
if (nopeus > 120) {
System.out.println("Ylinopeussakko!");
}
}
}
```

+ 68
- 0
2_conditionals/2_Katsastus.md View File

@ -0,0 +1,68 @@
Tee ohjelma Katsastus, jolla voidaan selvittää katsastusasemalla käynnin hinta.
- pelkkä jälkitarkastus maksaa 30. (Tällöin ei mitata päästöjä.)
- katsastus maksaa 50
- jos katsastuksessa mitataan päästö, bensiiniautolla se on 22 ja dieselautolla 31
- jos katsastuksessa ei mitata päästöjä, ohjelma ei kysy auton polttoaineen tyyppiä.
```
Example output:
Onko 1=katsastus, 2=jälkitarkastus: 1
Mitataanko päästöt 0=ei, 1=kyllä: 1
Onko auto 0=bensa, 1=diesel: 1
Hinta on 81
```
--------------------
**Katsastus.java**
```
import java.util.Scanner;
import java.util.InputMismatchException;
public class Katsastus {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int hinta = 0;
System.out.print("Onko 1=katsastus, 2=jälkitarkastus: ");
int syote_katsastus = syote.nextInt();
if (syote_katsastus == 1) {
hinta += 50;
System.out.print("Mitataanko päästöt 0=ei, 1=kyllä: ");
int syote_paastot = syote.nextInt();
if (syote_paastot == 1) {
System.out.print("Onko auto 0=bensa, 1=diesel: ");
int syote_polttoaine = syote.nextInt();
if (syote_polttoaine == 0) {
hinta += 22;
} else if (syote_polttoaine == 1) {
hinta += 31;
} /*else {
throw new InputMismatchException();
System.exit(1);
}*/
}
} else if (syote_katsastus == 2) {
hinta += 30;
} else {
throw new InputMismatchException();
System.exit(1);
}
System.out.println("Hinta on " + hinta);
}
}
```

+ 103
- 0
2_conditionals/4_Palkka.md View File

@ -0,0 +1,103 @@
Tee ohjelma Palkka, joka kysy käyttäjältä bruttopalkan, veroprosentin ja iän. Ohjelma laskee käteen jäävän osuuden palkasta sekä verojen, työttömyysvakuutuksen (1.5%) ja työeläkemaksun. Työeläkemaksu on 53-62 vuotiaalla 8.25% ja muilla 6.75%.
Veron osuus on palkka * veroprosentti / 100.0
Työeläkevakuutusmaksun osuus on palkka * XX, missä XX on joko 0.0825 tai 0.0675 riippuen iästä
Työttömyysvakuutuksen osuus on palkka * 0.015
Käteen jäävä osuus on palkka - vero - työttömyysvakuutus - työeläkevakuutusmaksu
```
Example output:
Anna palkka: 3000
Anna veroprosentti: 20
Anna ikä: 25
Bruttopalkka 3000
Veron osuus 600,00
Työeläkevakuutusmaksun osuus 202,50
Työttömyysvakuutuksen osuus 45,00
Käteen jää 2152,50
```
--------------------
**Palkka.java**
```
import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.InputMismatchException;
public class Palkka {
public static void main(String[] args) {
DecimalFormat r2 = new DecimalFormat("0.00");
Scanner syote = new Scanner(System.in);
try {
System.out.print("Anna palkka: ");
double palkka = syote.nextDouble();
if (palkka < 0 || palkka > 100000) {
throw new InputMismatchException();
}
System.out.print("Anna veroprosentti: ");
double veroprosentti = syote.nextDouble();
if (veroprosentti < 0) {
throw new InputMismatchException();
}
System.out.print("Anna ikä: ");
int ika = syote.nextInt();
double tyoelakemaksu = 0;
if (ika < 0 || ika > 120) {
throw new InputMismatchException();
}
if (ika >= 53 && ika <= 62) {
tyoelakemaksu = 0.0825;
} else {
tyoelakemaksu = 0.0675;
}
int bruttopalkka = (int)palkka;
double vero_osuus = palkka * veroprosentti / 100.0;
double tyoelakevakuutusmaksu_osuus = palkka * tyoelakemaksu;
double tyottomyysvakuutus_osuus = palkka * 0.015;
double kulut = vero_osuus + tyoelakevakuutusmaksu_osuus + tyottomyysvakuutus_osuus;
double kateen_jaa_euroina = bruttopalkka - kulut;
System.out.printf(
"Bruttopalkka %s\n" +
"Veron osuus %s\n" +
"Työeläkevakuutusmaksun osuus %s\n" +
"Työttömyysvakuutuksen osuus %s\n" +
"Käteen jää %s",
bruttopalkka,
r2.format(vero_osuus),
r2.format(tyoelakevakuutusmaksu_osuus),
r2.format(tyottomyysvakuutus_osuus),
r2.format(kateen_jaa_euroina)
);
} catch (InputMismatchException e) {
System.err.println("Virheellinen syöte");
System.exit(1);
}
}
}
```

+ 82
- 0
2_conditionals/5_Peltipoliisi.md View File

@ -0,0 +1,82 @@
Peltipoliisi on 80 nopeusrajoitusalueella. Jos alueella ajaa ylinopeutta korkeintaan 20 kilometriä tunnissa, saa rikesakon. Jos ylinopeus on yli 20 kilometriä, tulee päiväsakkoa. Päiväsakon rahamäärä määräytyy vähentämällä nettokuukausituloista peruskulutusvähennys 255 euroa ja jakamalla saatu erotus luvulla 60 eli (nettotulo-255)/60. Päiväsakon alin euromäärä on vähintään 6 euroa.
Tee ohjelma Peltipoliisi, joka kertoo, menikö ajetulla nopeudella rikesakolle vai päiväsakolle. Jos meni päiväsakolle, kerro yhden päiväsakon määrä. Jos annettu nopeus ei ole ylinopeutta, tulostaa ohjelma "Ei sakkoja". Jos tulee vain rikesakko, tulostaa ohjelmasi vain tekstin "Rikesakko".
Mikäli ylinopeus on yli 20 km/h, täytyy ohjelmasi tulostaa teksti "Päiväsakko" ja kysyä kuljettajan kuukausitulot. Lopuksi tulosta yhden päiväsakon määrä annetuilla tuloilla esimerkkisuorituksen mukaisesti.
```
Example output:
Anna nopeutesi: 101
Päiväsakko
Anna nettokuukausitulosi: 400,00
Päiväsakon määrä on 6,00 euroa
```
--------------------
**Peltipoliisi.java**
```
import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.InputMismatchException;
public class Peltipoliisi {
public static void main(String[] args) {
DecimalFormat r2 = new DecimalFormat("0.00");
Scanner syote = new Scanner(System.in);
int rajoitusalue = 80;
try {
System.out.print("Anna nopeutesi: ");
double nopeus = syote.nextDouble();
if (nopeus < 0 || nopeus > 999) {
throw new InputMismatchException();
}
if (nopeus <= rajoitusalue + 20) {
// rikesakko
System.out.println("Rikesakko");
}else if (nopeus >= rajoitusalue + 20) {
int peruskuluvahennys = 255;
// päiväsakko
System.out.println("Päiväsakko");
System.out.print("Anna nettokuukausitulosi: ");
double nettotulo = syote.nextDouble();
if (nettotulo < 0) {
throw new InputMismatchException();
}
double paivasakko_maara = (nettotulo - peruskuluvahennys) / 60;
if (paivasakko_maara < 6) {
paivasakko_maara = 6;
}
System.out.print("Päiväsakon määrä on " + r2.format(paivasakko_maara) + " euroa");
} else {
System.out.println("Ei sakkoja");
}
} catch (InputMismatchException e) {
System.err.println("Virheellinen syöte");
System.exit(1);
}
System.exit(0);
}
}
```

+ 122
- 0
3_loops/1_Toisto.md View File

@ -0,0 +1,122 @@
Kirjoita ohjelma Toisto.java, joka tulostaa kokonaisluvut väliltä 1-100. Kukin luku tulee tulostaa omalle rivilleen. Tarvitset tehtävän ratkaisemiseksi Toisto-nimisen luokan, main-metodin sekä while- tai for-toistokäskyn.
```
Example output:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
```
--------------------
**Toisto.java**
```
public class Toisto {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
}
}
```

+ 63
- 0
3_loops/2_Kilometrikorvaus.md View File

@ -0,0 +1,63 @@
Tee ohjelma Kilometrikorvaus, joka laskee omalla autolla ajojen kilometrikorvaukset. Ohjelma kysyy ajokilometrejä, kunnes käyttäjä antaa nollan. Tämän jälkeen ohjelma näyttää ajetut kilometrit sekä ajoista maksettavan korvauksen. Korvaus on 0.43 euroa per kilometri.
```
Example output:
Anna ajetut kilometrit (0 lopettaa): 12
Anna ajetut kilometrit (0 lopettaa): 13
Anna ajetut kilometrit (0 lopettaa): 98
Anna ajetut kilometrit (0 lopettaa): 73
Anna ajetut kilometrit (0 lopettaa): 160
Anna ajetut kilometrit (0 lopettaa): 0
Yhteensä 356 kilometriä
Korvaus on 153,08 euroa
```
--------------------
**Kilometrikorvaus.java**
```
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.InputMismatchException;
public class Kilometrikorvaus {
public static void main(String[] args) {
DecimalFormat r2 = new DecimalFormat("0.00");
double korvaus_euroa_km = 0.43, kilometrit = 0;
while (true) {
System.out.print("Anna ajetut kilometrit (0 lopettaa): ");
try {
Scanner syote = new Scanner(System.in);
double syote_kilometrit = syote.nextDouble();
if (syote_kilometrit < 0) {
System.err.println("Kilometri ei voi olla negatiivinen luku. Ohitetaan syöte");
continue;
} else {
kilometrit += syote_kilometrit;
}
if (syote_kilometrit == 0) {
break;
}
} catch (InputMismatchException e) {
System.err.println("Kilometrin täytyy olla luku. Ohitetaan syöte");
}
}
double korvaus_euroa_yht = kilometrit * korvaus_euroa_km;
System.out.printf(
"Yhteensä %s kilometriä\n" + "Korvaus on %s euroa",
(int)kilometrit,
r2.format(korvaus_euroa_yht)
);
}
}
```

+ 62
- 0
3_loops/3_Kotitalousvahennys.md View File

@ -0,0 +1,62 @@
Tee ohjelma Kotitalousvahennys, joka laskee käyttäjän saaman kotitalousvähennyksen määrän. Työkorvausten euromääriä kysytään niin kauan, kunnes käyttäjä antaa korvauksen määräksi nolla. Kotitalousvähennyksen määrä on 50 % työkorvauksesta. Kotitalousvähennyksen vähimmäismäärä on 0 euroa ja enimmäismäärä 2 400 euroa. Vähennyksen omavastuu on 100 euroa. Kotitalousvähennys lasketaan työkorvausten summa * 50 / 100.0 - omavastuu.
```
Example output:
Anna työkorvauksen määrä (0 lopettaa): 2000,0
Anna työkorvauksen määrä (0 lopettaa): 1000,0
Anna työkorvauksen määrä (0 lopettaa): 3000,0
Anna työkorvauksen määrä (0 lopettaa): 0
Kotitalousvähennyksen määrä on 2400,00 euroa
```
--------------------
**Kotitalousvahennys.java**
```
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.InputMismatchException;
public class Kotitalousvahennys {
public static void main(String[] args) {
DecimalFormat r2 = new DecimalFormat("0.00");
double omavastuu = 100, tyokorvaus = 0;
while (true) {
System.out.print("Anna työkorvauksen määrä (0 lopettaa): ");
try {
Scanner syote = new Scanner(System.in);
double syote_tyokorvaus = syote.nextDouble();
if (syote_tyokorvaus < 0) {
System.err.println("Työkorvauksen määrä ei voi olla negatiivinen luku. Ohitetaan syöte");
continue;
} else {
tyokorvaus += syote_tyokorvaus;
}
if (syote_tyokorvaus == 0) {
break;
}
} catch (InputMismatchException e) {
System.err.println("Työkorvauksen täytyy olla luku. Ohitetaan syöte");
}
}
double kotitalousvahennys = (tyokorvaus * 50 / 100.0) - omavastuu;
if (kotitalousvahennys > 2400) {
kotitalousvahennys = 2400;
} else if (kotitalousvahennys < 0) {
kotitalousvahennys = 0;
}
System.out.printf("Kotitalousvähennyksen määrä on %s euroa", r2.format(kotitalousvahennys) );
}
}
```

+ 113
- 0
3_loops/4_Opintopisteet.md View File

@ -0,0 +1,113 @@
Tee ohjelma Opintopisteet, joka kysyy, monesko lukukausi opiskelijalla on menossa. Tämän jälkeen ohjelma, kuinka monta opintopistettä opiskelija on saanut kunakin lukukautena. Lopuksi ohjelma kertoo
- kuinka paljon opiskelijalla pitäisi olla tähän mennessä opintopisteitä, kun lukukauden tavoite on 30 opintopistettä,
- opiskelijan yhteenlaskettujen opintopisteiden määrän,
- ilmoituksen, onko jäljessä tavoitteesta, tavoitteessa vai yli tavoitteen
("Olet jäljessä tavoitteesta.", "Olet tavoitteessa." tai "Olet edellä tavoitteesta.")
- vielä tutkintoon vaadittavien pisteiden määrän, kun tutkinto on 210 opintopistettä.
```
Example output:
Anna lukukausien määrä: 3
Anna 1. lukukauden opintopisteesi: 40
Anna 2. lukukauden opintopisteesi: 27
Anna 3. lukukauden opintopisteesi: 30
Sinulla pitäisi olla tähän mennessä 90 opintopistettä.
Sinulla on 97 opintopistettä.
Olet edellä tavoitteesta.
Tutkinnosta puuttuu vielä 113 opintopistettä.
```
--------------------
**Opintopisteet.java**
```
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.InputMismatchException;
public class Opintopisteet {
public static void main(String[] args) {
DecimalFormat r2 = new DecimalFormat("0.00");
Scanner syote_lukukausi = new Scanner(System.in);
int tutkinto_op = 210, lukukausi_op = 30;
System.out.print("Anna lukukausien määrä: ");
try {
int lukukaudet = syote_lukukausi.nextInt();
if (lukukaudet < 1 || lukukaudet > 8) {
System.err.println("Syötetty lukukausien määrä on virheellinen. Ohjelma keskeytetty");
System.exit(1);
}
String tavoite_lause = "";
int lukukausi_op_tavoite = 0, opiskelija_op_yht = 0;
for (int i = 1; i <= lukukaudet; i++) {
int max_tries = 4;
System.out.print("Anna " + i + ". lukukauden opintopisteesi: ");
while (max_tries > 0) {
try {
Scanner syote_op = new Scanner(System.in);
int opiskelija_op = syote_op.nextInt();
if (opiskelija_op < 0) {
throw new InputMismatchException();
} else {
opiskelija_op_yht += opiskelija_op;
}
lukukausi_op_tavoite += lukukausi_op;
break;
} catch (InputMismatchException e) {
System.err.println(
"Opintopisteiden täytyy olla positiivinen kokonaisluku\n" +
"Yritä uudelleen (kertoja jäljellä: " + (max_tries - 1) + ")"
);
max_tries -= 1;
continue;
}
}
if (max_tries == 0) {
System.err.println("Syöttämäsi opintopisteet ovat virheelliset. Ohjelma keskeytetty");
System.exit(1);
}
}
if (opiskelija_op_yht > lukukausi_op_tavoite) {
tavoite_lause = "Olet edellä tavoitteesta.";
} else if (opiskelija_op_yht == lukukausi_op_tavoite) {
tavoite_lause = "Olet tavoitteessa.";
} else {
tavoite_lause = "Olet jäljessä tavoitteesta.";
}
System.out.printf(
"Sinulla pitäisi olla tähän mennessä %s opintopistettä.\n" +
"Sinulla on %s opintopistettä.\n" +
"%s\n" + "Tutkinnosta puuttuu vielä %s opintopistettä.",
lukukausi_op_tavoite,
opiskelija_op_yht,
tavoite_lause,
(tutkinto_op - opiskelija_op_yht)
);
} catch (InputMismatchException e) {
System.err.println("Lukukauden täytyy olla kokonaisluku. Ohjelma keskeytetty");
System.exit(1);
}
}
}
```

+ 95
- 0
3_loops/5_Lahtolaskenta.md View File

@ -0,0 +1,95 @@
Kirjoita luokka Lahtolaskenta ja siihen main-metodi, joka tulostaa lukuja alaspäin sadasta yhteen. Ohjelman tulee jättää tulostamatta kaikki kolmella jaolliset luvut.
Jaollisuuden voit tarkastaa jakojäännösoperaattorilla (%). Luku on jaollinen toisella, kun jakojäännös on 0. X on siis jaollinen Y:llä, jos X % Y == 0.
```
Example output:
100
98
97
95
94
92
91
89
88
86
85
83
82
80
79
77
76
74
73
71
70
68
67
65
64
62
61
59
58
56
55
53
52
50
49
47
46
44
43
41
40
38
37
35
34
32
31
29
28
26
25
23
22
20
19
17
16
14
13
11
10
8
7
5
4
2
1
```
--------------------
**Lahtolaskenta.java**
```
public class Lahtolaskenta {
public static void main(String[] args) {
int i = 100;
while (i > 0) {
if (i % 3 != 0) {
System.out.println(i);
}
i--;
}
}
}
```

+ 67
- 0
3_loops/6_Alkuluku.md View File

@ -0,0 +1,67 @@
"Alkuluku on lukua 1 suurempi luonnollinen luku, joka ei ole jaollinen muilla positiivisilla kokonaisluvuilla kuin yhdellä ja itsellään." - Wikipedia
Kirjoita ohjelma Alkuluku, joka kysyy käyttäjältä yhden kokonaisluvun, ja laskee onko käyttäjän syöttämä luku alkuluku.
Voit ratkaista tehtävän tekemällä toistorakenteen, jossa kokeilet jakaa käyttäjän antamaa lukua sitä pienemmillä kokonaisluvuilla. Aloita luvusta 2 ja jatka kokeilemista luku kerrallaan, kunnes saavutat sopivan ylärajan, jonka jälkeen jako ei voi enää mennä tasan. Jos jollain kierroksella jako menee tasan, ei käyttäjän antama luku ole alkuluku. Jos puolestaan toistorakenne päättyy ilman, että yksikään jako on mennyt tasan, annettu luku on alkuluku.
Esimerkkisuoritus kun annettu luku ei ole alkuluku:
```
Syötä jokin positiivinen kokonaisluku: 93
Luku 93 ei ole alkuluku.
```
Esimerkkisuoritus kun annettu luku on alkuluku:
```
Syötä jokin positiivinen kokonaisluku: 97
Luku 97 on alkuluku.
```
```
Example output:
Syötä jokin positiivinen kokonaisluku: 4
Luku 4 ei ole alkuluku.
```
--------------------
**Alkuluku.java**
```
import java.util.Scanner;
import java.util.InputMismatchException;
public class Alkuluku {
public static void main(String[] args) {
//while(true) {
String tulos_lause = "on alkuluku";
Scanner syote = new Scanner(System.in);
System.out.print("Syötä jokin positiivinen kokonaisluku: ");
try {
int luku = syote.nextInt();
if (luku <= 1) {
throw new InputMismatchException();
}
for (int i = 2; i <= luku / 2; i++) {
if (luku % i == 0) {
tulos_lause = "ei ole alkuluku";
}
}
System.out.printf("Luku %s %s.\n", luku, tulos_lause);
} catch (InputMismatchException e) {
System.err.println("Syötteen tulee olla lukua 1 suurempi kokonaisluku");
}
//}
}
}
```

+ 57
- 0
4_strings/1_MerkkijonojenVertailu.md View File

@ -0,0 +1,57 @@
Alla on esitetty luokka MerkkijonojenVertailu, jonka tarkoitus on pyytää käyttäjältä kaksi merkkijonoa ja kertoa, ovatko annetut merkkijonot samat. Ohjelma ei kuitenkaan tällä hetkellä toimi halutulla tavalla.
Tallenna alla esitetty virheellisesti toimiva ohjelma itsellesi tiedostoon MerkkijonojenVertailu.java. Tutki ohjelmaa ja palauta korjattu versio ohjelmasta Viopeen:
```
import java.util.Scanner;
public class MerkkijonojenVertailu {
public static void main(String[] args) {
Scanner lukija = new Scanner(System.in);
System.out.println("Syötä kaksi merkkijonoa:");
String eka = lukija.nextLine();
String toka = lukija.nextLine();
if (eka == toka) {
System.out.println("Syötetyt merkkijonot olivat samat!");
} else {
System.out.println("Syötetyt merkkijonot eivät olleet samat!");
}
}
}
```
Tehtävä on lainattu Helsingin Yliopiston ohjelmointikurssilta ja se on lisensoitu Creative Commons BY-NC-SA-lisenssillä. https://2017-ohjelmointi.github.io/part1/#exercise-25-merkkijonojen-vertailu
```
Example output:
Syötä kaksi merkkijonoa:
esimerkki
example
Syötetyt merkkijonot eivät olleet samat!
```
--------------------
**MerkkijonojenVertailu.java**
```
import java.util.Scanner;
public class MerkkijonojenVertailu {
public static void main(String[] args) {
Scanner lukija = new Scanner(System.in);
System.out.println("Syötä kaksi merkkijonoa:");
String eka = lukija.nextLine();
String toka = lukija.nextLine();
if (eka.equals(toka)) {
System.out.println("Syötetyt merkkijonot olivat samat!");
} else {
System.out.println("Syötetyt merkkijonot eivät olleet samat!");
}
}
}
```

+ 18
- 0
4_strings/2_HelloWorld.md View File

@ -0,0 +1,18 @@
Kirjoita luokka HelloWorld ja siihen main-metodi, joka tulostaa tekstin Hello "world". Huomaa, että sanan world ympärille tulee tulostaa lainausmerkit.
```
Example output:
Hello "world"
```
--------------------
**HelloWorld.java**
```
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello \"world\"");
}
}
```

+ 71
- 0
4_strings/3_Lumi.md View File

@ -0,0 +1,71 @@
Tee ohjelma Lumi, joka kysyy nimiä, kunnes nimeksi annetaan LOPPU. Ohjelma kertoo, montako nimeä annettiin sekä montako kertaa annettiin nimi Lumi. Käyttäjä voi syöttää nimen suurilla ja pienillä kirjaimilla.
```
Example output:
Anna nimi: Matti
Anna nimi: LuMI
Anna nimi: Maija
Anna nimi: lumi
Anna nimi: LOPPU
Nimiä oli 4 kappaletta.
Nimi Lumi esiintyi 2 kertaa.
```
--------------------
**Lumi.java**
```
import java.util.Scanner;
public class Lumi {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
String nimi;
int nimiCount;
String specialNimi;
int specialNimiCount;
boolean isSpecialNimi;
nimiCount = 0;
specialNimiCount = 0;
specialNimi = "lumi";
isSpecialNimi = false;
while (true) {
System.out.print("Anna nimi: ");
nimi = syote.next();
if (nimi.equalsIgnoreCase(specialNimi)) {
isSpecialNimi = true;
nimiCount += 1;
specialNimiCount += 1;
}
if (nimi.equals("LOPPU")) {
break;
}
if (!isSpecialNimi) {
nimiCount += 1;
}
isSpecialNimi = false;
}
System.out.printf("Nimiä oli %s kappaletta.\n", nimiCount);
System.out.printf(
"Nimi %s esiintyi %s kertaa.",
// Capitalize first letter
specialNimi.substring(0,1).toUpperCase() + specialNimi.substring(1),
specialNimiCount
);
}
}
```

+ 61
- 0
4_strings/4_Tuotteet.md View File

@ -0,0 +1,61 @@
Tee ohjelma Tuotteet, joka kysyy tuotteen tiedot (numero, nimi, hinta ja kuvaus). Nimestä poistetaan tyhjät merkit alusta sekä lopusta, ja nimi muunnetaan suurella kirjoitetuksi. Kuvauksesta poistetaan tyhjät merkit alusta ja lopusta.
Jos kuvaus on tyhjä merkkijono, kuvausriviä ei tulosteta lainkaan.
Huom! Kun luette käyttäjältä numeroita ja tekstiä vuoron perään nextInt-, nextDouble- ja nextLine-metodeilla, jää "tietovirtaan" rivinvaihtomerkkejä. Tätä ongelmaa käsitellään Stack Overflow -keskustelussa: https://stackoverflow.com/a/13102066
```
Example output:
Anna tuotenumero: 1234
Anna tuotteen nimi: Porsche
Anna tuotteen hinta: 423000,00
Anna tuotteen kuvaus: Punainen
Numero: 1234
Nimi: PORSCHE
Hinta: 423000,00
Kuvaus: Punainen
```
--------------------
**Tuotteet.java**
```
import java.util.Scanner;
import java.text.DecimalFormat;
public class Tuotteet {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
DecimalFormat r2 = new DecimalFormat(".00");
int tuotenumero;
String nimi, kuvaus;
double hinta;
System.out.print("Anna tuotenumero: ");
tuotenumero = syote.nextInt();
System.out.print("Anna tuotteen nimi: ");
nimi = syote.next();
System.out.print("Anna tuotteen hinta: ");
hinta = syote.nextDouble();
System.out.print("Anna tuotteen kuvaus: ");
kuvaus = syote.next();
// Remove leading & trailing spaces, convert to uppercase
nimi = nimi.trim().toUpperCase();
kuvaus = kuvaus.trim();
System.out.printf(
"Numero: %s\nNimi: %s\nHinta: %s\n",
tuotenumero, nimi, r2.format(hinta)
);
if (!kuvaus.isEmpty()) {
System.out.printf("Kuvaus: %s\n", kuvaus);
}
}
}
```

+ 40
- 0
4_strings/5_Osamerkkijonot.md View File

@ -0,0 +1,40 @@
Kirjoita luokka AlkuTulostin ja siihen main-metodi, joka kysyy käyttäjältä sanan ja joka tulostaa annetun sanan alkuosaa toistuvasti. Ensimmäisellä kerralla tulostetaan vain ensimmäinen kirjain ja jokaiseen seuraavaan tulosteeseen otetaan yksi kirjain lisää. Sanan tulostaminen lopetetaan, kun annettu sana on tulostettu kokonaisena.
```
Example output:
Kirjoita sana: ratkaisu
r
ra
rat
ratk
ratka
ratkai
ratkais
ratkaisu
```
--------------------
**AlkuTulostin.java**
```
import java.util.Scanner;
import java.lang.StringBuilder;
public class AlkuTulostin {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
StringBuilder sana_current = new StringBuilder("");
int i;
System.out.print("Kirjoita sana: ");
String sana = syote.next();
for (i = 0; i < sana.length(); i++) {
System.out.println(sana_current.append(sana.charAt(i)));
}
}
}
```

+ 76
- 0
4_strings/6_Lento.md View File

@ -0,0 +1,76 @@
Tee ohjelma Lento, jolla voidaan selvittää lennon numerosta, onko kyseessä Finnairin lento. Jos lennon numeron alussa on AY, kyseessä on Finnairin lento. Jos kyseessä on Finnairin lento, selvitetään lisäksi, onko kyseessä kaukolento, kotimaan lento vai Venäjän lento. Jos lennon numeron kolmas merkki on 1, kyseessä on kaukolento, 2-6 kotimaan lento, 7 Venäjän lento. Merkkijonon voi muuntaa numeroksi
int numero = Integer.parseInt(merkkijono);
Ohjelman sallitut tulosteet ovat: "Kaukolento", "Kotimaan lento", "Venäjän lento" tai "Ei ole Finnairin lento".
```
Example output:
Anna lennon numero: AY105
Kaukolento
```
--------------------
**Lento.java**
```
import java.util.Scanner;
public class Lento {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
String lentoID = "";
String lentoTyyppi = "";
boolean lentoFinnair = false;
int lentoIDLength = 5;
System.out.print("Anna lennon numero: ");
lentoID = syote.next();
if (lentoID.length() == lentoIDLength) {
if (lentoID.substring(0,2).equals("AY")) {
lentoFinnair = true;
}
// if numID is not integer, throw exception and exit
try {
// Obtain third character of the input string
// charAt sets data type to 'char', thus String.valueOf() method is required
// for char to String conversion
// Convert String to int using Integer.parseInt() method
int numID = Integer.parseInt(String.valueOf(lentoID.charAt(2)));
if (lentoFinnair) {
switch(numID) {
case 1:
lentoTyyppi = "Kaukolento";
break;
case 7:
lentoTyyppi = "Venäjän lento";
break;
default:
if (numID >= 2 && numID <= 6) {
lentoTyyppi = "Kotimaan lento";
} else {
System.err.println("Tuntematon lentotyyppi");
System.exit(1);
}
break;
}
}
System.out.println(lentoTyyppi);
} catch (NumberFormatException e) {
System.err.println("Lennon numero-osan alku ei ole oikein. Tarkista ja yritä uudelleen");
System.exit(1);
}
} else {
System.out.println("Ei ole Finnairin lento");
}
}
}
```

+ 54
- 0
4_strings/7_RekisterinumeroTarkistin.md View File

@ -0,0 +1,54 @@
"Auton rekisteritunnus koostuu 2–3 kirjaimen ja enintään kolminumeroisen luvun yhdistelmästä. Kirjain- ja lukusarja on erotettu toisistaan väliviivalla." - Liikenteen turvallisuusvirasto (Traficom)
Kirjoita ohjelma RekisterinumeroTarkastin.java, joka kysyy käyttäjältä autojen rekisterinumeroita, ja kertoo, onko annettu rekisterinumero kelvollinen. Rekisterinumerot tulee voida antaa kirjainkoosta riippumatta, eli joko isoilla tai pienillä kirjaimilla. Kirjaimet saavat koostua ainoastaan suomenkielisistä aakkosista.
Rekisterinumeroiden kysyminen tulee lopettaa ja ohjelman suorituksen tulee päättyä, kun käyttäjä syöttää ainoastaan "q"-kirjaimen.
Tehtävä on ratkaistava käyttäen säännöllistä lauseketta ja String-luokan matches-metodia.
```
Example output:
Syötä rekisterinumero (q-kirjain lopettaa): JAV-4
JAV-4 on kelvollinen rekisterinumero.
Syötä rekisterinumero (q-kirjain lopettaa): AB-C12
AB-C12 ei ole kelvollinen rekisterinumero.
Syötä rekisterinumero (q-kirjain lopettaa): ABC-12 AB-3
ABC-12 AB-3 ei ole kelvollinen rekisterinumero.
Syötä rekisterinumero (q-kirjain lopettaa): q
```
--------------------
**RekisterinumeroTarkastin.java**
```
import java.util.Scanner;
public class RekisterinumeroTarkastin {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
while (true) {
System.out.print("Syötä rekisterinumero (q-kirjain lopettaa): ");
String rekisteriNro = syote.nextLine();
// No need for [a-zA-Z] regex
rekisteriNro = rekisteriNro.toUpperCase();
if (rekisteriNro.equals("Q")) {
break;
}
if (!rekisteriNro.matches("^[A-ZÅÄÖ]{2,3}-[0-9]{1,3}$")) {
System.out.printf("%s ei ole kelvollinen rekisterinumero.\n", rekisteriNro);
} else {
System.out.printf("%s on kelvollinen rekisterinumero.\n", rekisteriNro);
}
}
}
}
```

+ 77
- 0
5_lists/10_KysytynLuvunIndeksi.md View File

@ -0,0 +1,77 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Lisää ohjelmaan toiminnallisuus, joka kysyy käyttäjältä lukua ja kertoo luvun indeksin. Mikäli lukua ei löydy, ohjelman ei tule kertoa siitä. Jos etsitty luku löytyy listalta monesta kohdasta, tulee kaikki indeksit tulostaa omilla riveillään.
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
8
11
-1
Mitä lukua etsitään? 8
Luku 8 on indeksissä 2
Luku 8 on indeksissä 3
```
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava10/KysytynLuvunIndeksi.java
--------------------
**KysytynLuvunIndeksi.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class KysytynLuvunIndeksi {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
errorInvalidIntegerInput();
}
}
try {
System.out.print("Mitä lukua etsitään? ");
int etsiLuku = syote.nextInt();
for (i = 0; i < lukulista.size(); i++) {
if (lukulista.get(i) == etsiLuku) {
System.out.printf("Luku %s on indeksissä %s\n", etsiLuku, i);
}
}
} catch (NumberFormatException e) {
errorInvalidIntegerInput();
}
}
private static void errorInvalidIntegerInput() {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
```

+ 64
- 0
5_lists/11_LustanLukujenSumma.md View File

@ -0,0 +1,64 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Lisää ohjelmaan toiminnallisuus, joka lukujen lukemisen jälkeen laskee ja tulostaa listalla olevien lukujen summan.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava12/ListanLukujenSumma.java
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
11
11
-1
Summa: 104
```
--------------------
**ListanLukujenSumma.java**
```
/* Tässä ei ole käytetty valmista pohjaa lainkaan */
import java.util.ArrayList;
import java.util.Scanner;
public class ListanLukujenSumma {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i, sum = 0;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
// Print sum of all integers in lukulista ArrayList
for (i = 0; i < lukulista.size(); i++) {
sum += lukulista.get(i);
}
System.out.printf("Summa: %s\n", sum);
}
}
```

+ 64
- 0
5_lists/12_ListanLukujenKeskiarvo.md View File

@ -0,0 +1,64 @@
Toteuta ohjelma, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Kun lukujen lukeminen lopetetaan, laske listalla olevien lukujen keskiarvo ja tulosta se. Tulostettua keskiarvoa ei tule muotoilla eikä pyöristää. Voit hyödyntää tehtävän ratkaisemisessa tehtäväpohjaa.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava13/ListanLukujenKeskiarvo.java
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
11
-1
Keskiarvo: 23.25
```
--------------------
**ListanLukujenKeskiarvo.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
import java.text.DecimalFormat;
public class ListanLukujenKeskiarvo {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
DecimalFormat r2 = new DecimalFormat(".00");
int i, sum = 0;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
for (i = 0; i < lukulista.size(); i++) {
sum += lukulista.get(i);
}
System.out.printf("Keskiarvo: %s\n", ((double)sum/lukulista.size()));
}
}
```

+ 68
- 0
5_lists/13_LoytyykoListalta.md View File

@ -0,0 +1,68 @@
Tehtäväpohjassa on ohjelma, joka lukee käyttäjältä syötteitä. Lisää ohjelmaan toiminnallisuus, missä syötteiden lukemisen jälkeen kysytään vielä yhtä merkkijonoa. Ohjelma kertoo tämän jälkeen löytyikö käyttäjän syöttämä merkkijono listalta vai ei.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava14/LoytyykoListalta.java
```
Example output:
Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:
Terho
Elina
Aleksi
Mari
-
Ketä etsitään? Leevi
Leevi ei löytynyt!
```
--------------------
**LoytyykoListalta.java**
```
/* Ei ole käytetty valmista mallipohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class LoytyykoListalta {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i = 0;
boolean nimiLoytynyt = false;
ArrayList<String> sanalista = new ArrayList<String>();
System.out.println("Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:");
while (true) {
String sana = syote.nextLine();
if (sana.equals("-") || sana.isEmpty()) {
break;
}
sanalista.add(sana);
}
System.out.print("Ketä etsitään? ");
String etsiSana = syote.nextLine();
while(!nimiLoytynyt && i < sanalista.size()) {
if (sanalista.get(i).equalsIgnoreCase(etsiSana)) {
nimiLoytynyt = true;
break;
}
i++;
}
if (!nimiLoytynyt) {
System.out.printf("%s ei löytynyt!\n", etsiSana);
} else {
System.out.printf("%s löytyi!\n", etsiSana);
}
}
}
```

+ 139
- 0
5_lists/14_KaupungitVerkosta.md View File

@ -0,0 +1,139 @@
Scanner-olioilla voidaan lukea monia erilaisia tietovirtoja. Olemme tähän asti lukeneet lähinnä käyttäjien syötteitä System.in-tietovirrasta, mutta Scanneria voidaan käyttää myös esimerkiksi tiedostojen ja verkkolähteiden lukemiseen.
Tässä tehtävässä sinun tulee lukea verkosta kaupunkien nimet ja väkiluvut ja tulostaa sellaisten kaupunkien nimet, joiden väkiluku on yli 10 000 asukasta. Käytä pohjana KaupungitVerkosta.java-tiedostoa.
KaupungitVerkosta-luokan logiikka on toteutettu siten, että kaupungin nimi tulostetaan heti kyseistä riviä läpikäytäessä. Tässä tehtävässä sinun tulee muuttaa toimintalogiikkaa niin, että nimet tulostetaan aakkosjärjestyksessä.
Aakkosjärjestyksen toteuttamiseksi sinun tuleekin laittaa yli 10 000 asukkaan kaupunkien nimet talteen listalle kunnes kaikki kaupungit on käyty läpi. Sen jälkeen järjestä lista Collections.sort-metodin avulla, ja lopuksi tulosta listan alkiot yksi kerrallaan.
Pohja: https://github.com/haagahelia/swd4tn032-TH_JJ/blob/master/src/viikko3/listat/th/KaupungitVerkosta.java
Collections.sort: https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#sort-java.util.List-
```
Example output:
Akaa
Alavus
Espoo
Forssa
Hamina
Heinola
Helsinki
Huittinen
Hyvinkää
Hämeenlinna
Iisalmi
Imatra
Joensuu
Jyväskylä
Jämsä
Järvenpää
Kaarina
Kajaani
Kalajoki
Kangasala
Kankaanpää
Kauhajoki
Kauhava
Kemi
Kerava
Kitee
Kokkola
Kotka
Kouvola
Kuopio
Kurikka
Kuusamo
Lahti
Lappeenranta
Lapua
Lieksa
Lohja
Loimaa
Loviisa
Maarianhamina
Mikkeli
Naantali
Nivala
Nokia
Orimattila
Oulu
Paimio
Parainen
Pieksämäki
Pietarsaari
Pori
Porvoo
Raahe
Raasepori
Raisio
Rauma
Riihimäki
Rovaniemi
Salo
Sastamala
Savonlinna
Seinäjoki
Tampere
Tornio
Turku
Ulvila
Uusikaupunki
Vaasa
Valkeakoski
Vantaa
Varkaus
Ylivieska
Ylöjärvi
Äänekoski
```
--------------------
**KaupungitVerkosta.java**
```
// Ref: https://github.com/haagahelia/swd4tn032-TH_JJ/blob/master/src/viikko3/listat/th/KaupungitVerkosta.java
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class KaupungitVerkosta {
// Define Exception for unreachable URLs
public static void main(String[] args) throws Exception {
URL csvFile = new URL("https://git.io/Jv3N3");
ArrayList<String> cityList = new ArrayList<String>();
int i;
Scanner syote = new Scanner(csvFile.openStream(), "UTF-8");
// Exclude header line
String firstLine = syote.nextLine();
while (syote.hasNextLine()) {
String line = syote.nextLine();
// CSV delimiter is character ,
int lineIndex = line.indexOf(",");
String city = line.substring(0, lineIndex);
int population = Integer.parseInt(line.substring(lineIndex + 1));
if (population >= 10000) {
cityList.add(city);
}
}
syote.close();
Collections.sort(cityList);
for (i= 0; i < cityList.size(); i++) {
System.out.println(cityList.get(i));
}
}
}
```

+ 53
- 0
5_lists/1_KolmannenArvonTulostaminen.md View File

@ -0,0 +1,53 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä merkkijonoja ja lisää niitä listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää tyhjän merkkijonon tai väliviivan. Ohjelma tulostaa tämän jälkeen listan ensimmäisen arvon.
Muokkaa ohjelmaa siten, että ensimmäisen arvon sijaan tulostetaan kolmas arvo. Huomaa, että ohjelmoijat aloittavat laskemisen nollasta! Ohjelma saa rikkoutua mikäli listalla ei ole vähintään kolmea arvoa, eli tällaiseen tilanteeseen ei tarvitse varautua millään tavalla.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava01/KolmannenArvonTulostaminen.java
```
Example output:
Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:
Elina
Aleksi
Mari
-
Mari
```
--------------------
**KolmannenArvonTulostaminen.java**
```
/* Oma versio, ei mallipohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class KolmannenArvonTulostaminen {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
ArrayList<String> sanalista = new ArrayList<String>();
System.out.println("Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:");
while (true) {
String sana = syote.nextLine();
if (sana.equals("-") || sana.isEmpty()) {
break;
}
sanalista.add(sana);
}
// Print the third value
System.out.println(sanalista.get(2));
// Print the last value
//System.out.println(sanalista.get(sanalista.size() - 1));
}
}
```

+ 71
- 0
5_lists/2_ToisenJaKolmannenSumma.md View File

@ -0,0 +1,71 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä kokonaistyyppisiä lukuja ja lisää niitä listalle. Lukeminen lopetetaan kun käyttäjä syöttää luvun 0. Ohjelma tulostaa tämän jälkeen listan ensimmäisen arvon.
Muokkaa ohjelmaa siten, että listan ensimmäisen arvon sijaan ohjelma tulostaa listan toisen ja kolmannen arvon summan. Ohjelma saa rikkoutua mikäli listalla ei ole vähintään kolmea arvoa, eli tällaiseen tilanteeseen ei tarvitse varautua millään tavalla.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava02/ToisenJaKolmannenSumma.java
```
Example output:
Syötä kokonaislukuja listalle (0 lopettaa):
2
3
4
0
7
```
--------------------
**ToisenJaKolmannenSumma.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class ToisenJaKolmannenSumma {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i, sum = 0;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (0 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == 0) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
// Print sum of all integers in lukulista ArrayList
/*
for (i = 0; i < lukulista.size(); i++) {
sum += lukulista.get(i);
}
*/
if (lukulista.size() >= 3) {
sum += lukulista.get(1) + lukulista.get(2);
} else {
System.out.println("Et ole antanut riittävästi lukuja. Syötä vähintään 3 lukua");
System.exit(0);
}
System.out.println(sum);
}
}
```

+ 40
- 0
5_lists/3_IndexOutOfBounds.md View File

@ -0,0 +1,40 @@
Lista on erittäin hyödyllinen kun halutaan säilöä muuttujien arvoja myöhempää käsittelyä varten. Sillä on myös helpohko tehdä virheitä.
Tehtäväpohjassa on listaa käyttävä ohjelma. Muokkaa ohjelmaa siten, että sen suorittaminen tuottaa aina virheen IndexOutOfBoundsException. Ohjelman tulee olla sellainen, että käyttäjän ei tarvitse antaa koneelle syötettä (esim. näppäimistöltä).
Ohjelmassa näkyy myös tapa listan läpikäyntiin — palaamme tähän tapaan myöhemmin.
```
Example output:
Exception in thread "main" java.lang.IndexOutOfBoundsException...
```
--------------------
**IndexOutOfBounds.java**
```
// Ref: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava03/IndexOutOfBounds.java
import java.util.ArrayList;
import java.util.List;
public class IndexOutOfBounds {
public static void main(String[] args) {
List<String> sanalista = new ArrayList<>();
sanalista.add("Ensimmäinen");
sanalista.add("Toinen");
int kokonaispituus = 0;
for (int i = 0; i < sanalista.size(); i++) {
// This index never exists in the loop, thus resulting to IndexOutOfBoundsException
String sana = sanalista.get(i + 1);
kokonaispituus += sana.length();
}
}
}
```

+ 56
- 0
5_lists/4_ListanKoko.md View File

@ -0,0 +1,56 @@
Tehtäväpohjassa on ohjelma, joka lukee käyttäjältä syötteitä. Muokkaa ohjelman toimintaa siten, että kun syötteiden lukeminen lopetetaan, ohjelma tulostaa listalla olevien arvojen lukumäärän.
Huom! Käytä tässä listan valmiiksi tarjoamaa metodia size.
```
Example output:
Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:
Juno
Elizabeth
Mauri
Irene
Outi
Lauri
Iisa
Risto
Markus
Ville
Oskari
-
Yhteensä: 11
```
--------------------
**ListanKoko.java**
```
/* Ei ole käytetty valmista mallipohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class ListanKoko {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
ArrayList<String> sanalista = new ArrayList<String>();
System.out.println("Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:");
while (true) {
String sana = syote.nextLine();
if (sana.equals("-") || sana.isEmpty()) {
break;
}
sanalista.add(sana);
}
System.out.printf("Yhteensä: %s", sanalista.size());
}
}
```

+ 60
- 0
5_lists/5_ListanViimeinenArvo.md View File

@ -0,0 +1,60 @@
Tehtäväpohjassa on ohjelma, joka lukee käyttäjältä syötteitä ja lisää syötteet listalle. Syötteen lukeminen lopetetaan kun käyttäjä syöttää tyhjän merkkijonon tai yhdysviivan.
Muokkaa ohjelmaa siten, että kun syötteiden lukeminen lopetetaan, ohjelma tulostaa viimeksi luetun arvon. Tulosta viimeksi luettu arvo listalta. Käytä tässä hyödyksi listan koon kertovaa metodia.
HUOM! Tässä tehtävässä harjoitellaan listan ja indeksin käyttöä. Vaikka pystyisit tekemään tehtävän ilman listaa, keskity tehtävissä listan käytön harjoitteluun. Tehtävissä toivottu toiminnallisuus tulee toteuttaa syötteiden lukemisen jälkeen.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava05/ListanViimeinenArvo.java
```
Example output:
Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:
Juno
Elizabeth
Mauri
Irene
Outi
Lauri
Iisa
Risto
Markus
Ville
Oskari
-
Oskari
```
--------------------
**ListanViimeinenArvo.java**
```
/* Ei ole käytetty valmista mallipohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class ListanViimeinenArvo {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
ArrayList<String> sanalista = new ArrayList<String>();
System.out.println("Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:");
while (true) {
String sana = syote.nextLine();
if (sana.equals("-") || sana.isEmpty()) {
break;
}
sanalista.add(sana);
}
System.out.println(sanalista.get(sanalista.size() - 1));
}
}
```

+ 61
- 0
5_lists/6_EnsimmainenJaViimeinenArvo.md View File

@ -0,0 +1,61 @@
Tehtäväpohjassa on ohjelma, joka lukee käyttäjältä syötteitä ja lisää syötteet listalle. Syötteen lukeminen lopetetaan kun käyttäjä syöttää tyhjän merkkijonon tai yhdysviivan.
Muokkaa ohjelmaa siten, että kun syötteiden lukeminen lopetetaan, ohjelma tulostaa sekä ensiksi että viimeksi luetun arvon. Voit olettaa, että listalle luetaan vähintään kaksi arvoa.
HUOM! Tässä tehtävässä harjoitellaan listan ja indeksin käyttöä. Vaikka pystyisit tekemään tehtävän ilman listaa, keskity tehtävissä listan käytön harjoitteluun. Tehtävissä toivottu toiminnallisuus tulee toteuttaa syötteiden lukemisen jälkeen.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava06/EnsimmainenJaViimeinenArvo.java
```
Example output:
Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:
Juno
Elizabeth
Mauri
Irene
Outi
Lauri
Iisa
Risto
Markus
Ville
Oskari
-
Juno
Oskari
```
--------------------
**EnsimmainenJaViimeinenArvo.java**
```
/* Ei ole käytetty valmista mallipohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class EnsimmainenJaViimeinenArvo {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
ArrayList<String> sanalista = new ArrayList<String>();
System.out.println("Syötä sanoja listalle. Tyhjä tai yhdysviiva (-) lopettaa:");
while (true) {
String sana = syote.nextLine();
if (sana.equals("-") || sana.isEmpty()) {
break;
}
sanalista.add(sana);
}
System.out.printf("%s\n%s", sanalista.get(0), sanalista.get(sanalista.size() - 1));
}
}
```

+ 63
- 0
5_lists/7_ListanLuvut.md View File

@ -0,0 +1,63 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Lisää ohjelmaan toiminnallisuus, joka lukujen lukemisen jälkeen tulostaa käyttäjän syöttämät luvut. Syötteen lukemisen päättämisestä ilmoittavaa lukua ei tulosteta.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava07/ListanLuvut.java
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
11
-1
72
2
8
11
```
--------------------
**ListanLuvut.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class ListanLuvut {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
for (i = 0; i < lukulista.size(); i++) {
System.out.println(lukulista.get(i));
}
}
}
```

+ 79
- 0
5_lists/8_LuvutRajatullaAlueella.md View File

@ -0,0 +1,79 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Lisää ohjelmaan toiminnallisuus, joka lukujen lukemisen jälkeen kysyy käyttäjältä alkuindeksiä ja loppuindeksiä. Tämän jälkeen ohjelman tulostaa listalla olevat luvut käyttäjän syöttämien indeksien välillä. Voit olettaa, että käyttäjä syöttää indeksit, jotka löytyvät listalta.
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava08/LuvutRajatullaAlueella.java
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
11
-1
Mistä? 0
Mihin? 2
72
2
8
```
--------------------
**LuvutRajatullaAlueella.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class LuvutRajatullaAlueella {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
errorInvalidIntegerInput();
}
}
try {
System.out.print("Mistä? ");
int startInt = syote.nextInt();
System.out.print("Mihin? ");
int endInt = syote.nextInt();
for (i = 0; i < lukulista.size(); i++) {
if (i >= startInt && i <= endInt) {
System.out.println(lukulista.get(i));
}
}
} catch (NumberFormatException e) {
errorInvalidIntegerInput();
}
}
private static void errorInvalidIntegerInput() {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
```

+ 91
- 0
5_lists/9_ListanSuurinLuku.md View File

@ -0,0 +1,91 @@
Ohjelmaan on toteutettu valmiina pohja, joka lukee käyttäjältä lukuja listalle. Syötteiden lukeminen päätetään kun käyttäjä syöttää luvun -1.
Lisää ohjelmaan toiminnallisuus, joka lukujen lukemisen jälkeen etsii listalta listan suurimman luvun ja tulostaa sen arvon. Ohjelman pitäisi toimia esimerkkisuorituksen mukaisesti.
Ota mallia allaolevasta pienintä lukua etsivästä lähdekoodista:
```
// oletetaan, että käytössämme on lista, jossa on kokonaislukuja
int pienin = lista.get(0);
int indeksi = 0;
while (indeksi < lista.size()) {
int luku = lista.get(indeksi);
if (pienin > luku) {
pienin = luku;
}
indeksi = indeksi + 1;
}
System.out.println("Listan pienin luku: " + pienin);
```
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava09/ListanSuurinLuku.java
```
Example output:
Syötä kokonaislukuja listalle (-1 lopettaa):
72
2
8
93
11
-1
Listan suurin luku: 93
```
--------------------
**ListanSuurinLuku.java**
```
/* Tässä ei ole käytetty valmista pohjaa */
import java.util.ArrayList;
import java.util.Scanner;
public class ListanSuurinLuku {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i, currentNumber, suurin = 0;
ArrayList<Integer> lukulista = new ArrayList<Integer>();
System.out.println("Syötä kokonaislukuja listalle (-1 lopettaa):");
while (true) {
try {
int luku = syote.nextInt();
if (luku == -1) {
break;
}
lukulista.add(luku);
} catch (NumberFormatException e) {
errorInvalidIntegerInput();
}
}
for (i = 0; i < lukulista.size(); i++) {
currentNumber = lukulista.get(i);
if (currentNumber > suurin) {
suurin = currentNumber;
}
}
System.out.printf("Listan suurin luku: %s\n", suurin);
}
private static void errorInvalidIntegerInput() {
System.err.println("Antamasi syöte ei ole kokonaisluku");
System.exit(1);
}
}
```

+ 38
- 0
6_tables/1_MerkkijononPalat.md View File

@ -0,0 +1,38 @@
Kirjoita luokka MerkkijononPalat, jonka main-metodissa kysyt käyttäjältä merkkijonoa. Ohjelma pilkkoo tämän jälkeen merkkijonon osiin välilyöntien perusteella ja tulostaa osat yksitellen.
Hyödynnä merkkijonon pilkkomisessa taulukoksi String-luokan split-metodia. Pilko annettu lause välilyöntimerkkien kohdilta ja ota split-metodin palauttama merkkijonotaulukko (String[]) talteen uuteen muuttujaan. Lopuksi käy toistorakenteella taulukko läpi ja tulosta kukin arvo yksi kerrallaan.
```
Example output:
Kirjoita lause: Vesihiisi sihisi hississä
Vesihiisi
sihisi
hississä
```
--------------------
**MerkkijononPalat.java**
```
import java.util.Scanner;
public class MerkkijononPalat {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i = 0;
System.out.print("Kirjoita lause: ");
String lause = syote.nextLine();
String[] lauseTaulukko = lause.split(" ");
while(i < lauseTaulukko.length) {
System.out.println(lauseTaulukko[i]);
i++;
}
}
}
```

+ 73
- 0
6_tables/2_SanojenVaihtaminen.md View File

@ -0,0 +1,73 @@
Kirjoita luokka SanojenVaihtaminen ja lisää siihen main-metodi. Ohjelman tulee kysyä käyttäjältä lause ja sen jälkeen vaihtaa siitä kahden sanan paikkaa keskenään. Vaihdettavien sanojen indeksit kysytään käyttäjältä esimerkkisuorituksen mukaisesti ja indeksit alkavat totutusti nollasta.
Ohjelma kannattaa toteuttaa siten, että pilkot lauseen String-taulukoksi välilyöntien kohdalta. Sanoja vaihtaessasi tarvitset todennäköisesti tilapäisen muuttujan, johon laitat toisen alkuperäisistä sanoista talteen. Lopuksi voit yhdistää String-taulukon takaisin yhdeksi merkkijonoksi String-luokan join-metodilla siten, että erottimena käytetään jälleen välilyöntiä.
Jos tehtävän ratkaiseminen osoittautuu kohtuuttoman hankalaksi, voit tutustua tehtävän ratkaisuun videotallenteena.
```
Example output:
Kirjoita lause:
Parempi pyy pivossa kuin kymmenen oksalla
Mitkä sanat vaihdetaan keskenään?
2 5
Parempi pyy oksalla kuin kymmenen pivossa
```
--------------------
**SanojenVaihtaminen.java**
```
import java.util.Scanner;
public class SanojenVaihtaminen {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int i = 0;
System.out.println("Kirjoita lause: ");
String lause = syote.nextLine();
String[] lauseTaulukko = lause.split(" ");
System.out.println("Mitkä sanat vaihdetaan keskenään?");
String vaihtoSanat = syote.nextLine();
String[] vaihtoTaulukko = vaihtoSanat.split(" ");
// Length must be 2
if (vaihtoTaulukko.length != 2) {
System.err.println("Käytä kahta indeksiä. Olet määrittänyt väärän määrän indeksiarvoja");
System.exit(1);
}
// Switch two strings in table lauseTaulukko
try {
String temp = lauseTaulukko[Integer.parseInt(vaihtoTaulukko[0])];
lauseTaulukko[Integer.parseInt(vaihtoTaulukko[0])] = lauseTaulukko[Integer.parseInt(vaihtoTaulukko[1])];
lauseTaulukko[Integer.parseInt(vaihtoTaulukko[1])] = temp;
} catch (ArrayIndexOutOfBoundsException e) {
System.err.printf(
"Syöttämäsi indeksiarvo ylittää antamasi lauseen viimeisen indeksiarvon\n" +
"Lauseen viimeinen sallittu indeksiarvo on %s",
lauseTaulukko.length - 1
);
System.exit(1);
} catch (NumberFormatException e) {
System.err.printf(
"Syöttämäsi indeksiarvo ei ole kelvollinen kokonaisluku\n"
);
System.exit(1);
}
// Will be deleted by Java garbage collector
vaihtoTaulukko = null;
String output = String.join(" ", lauseTaulukko);
System.out.println(output);
}
}
```

+ 97
- 0
6_tables/3_MarsinLampotilat.md View File

@ -0,0 +1,97 @@
Toteuta ohjelma Mars-planeetan lämpötilamittausten tarkasteluun. Marsin alin lämpötila (pinnalla) on -140 astetta, korkein lämpötila on 20 astetta. Ohjelmalle tulee syöttää 10 hyväksyttyä mittaustulosta, jotka ohjelma kerää int[]-tyyppiseen taulukkoon, jonka pituus on 10. Jos käyttäjä syöttää luvun, joka on pienempi kuin -140 tai suurempi kuin 20, lukua ei laiteta taulukkoon vaan se pyydetään uudelleen esimerkkisuorituksen mukaisesti.
Lopuksi ohjelman tulee tulostaa lämpötilamittausten keskiarvo sekä minimi- ja maksimiarvot.
HUOM! Tehtävässä on tarkoitus harjoitella taulukoiden käyttöä, joten listojen käyttäminen on tässä tehtävässä kiellettyä.
Huom! Älä pyöristä lopussa tulostettavaa keskiarvoa
```
Example output:
Syötä mittaus 1/10: 10
Syötä mittaus 2/10: 19
Syötä mittaus 3/10: 18
Syötä mittaus 4/10: 15
Syötä mittaus 5/10: 1
Syötä mittaus 6/10: -1
Syötä mittaus 7/10: -12
Syötä mittaus 8/10: -200
Anna lämpötila väliltä -140 - +20!
Syötä mittaus 8/10: -88
Syötä mittaus 9/10: -85
Syötä mittaus 10/10: 21
Anna lämpötila väliltä -140 - +20!
Syötä mittaus 10/10: -72
Mittausten keskiarvo: -19.5
Pienin mittaustulos: -88
Suurin mittaustulos: 19
```
--------------------
**MarsinLampotilat.java**
```
//import java.text.DecimalFormat;
import java.util.InputMismatchException;
import java.util.Scanner;
public class MarsinLampotilat {
public static void main(String[] args) {
//DecimalFormat r1 = new DecimalFormat(".0");
int i = 0, lampoInput = 1, max = 10;
int minTemp = -140, maxTemp = 20;
String minTempPrefix = "", maxTempPrefix = "";
int lampoSumma = 0, currentTemp = 0, pienin = 0, suurin = 0;
int[] lampotilatMars = new int[max];
if (minTemp > 0) { minTempPrefix = "+"; }
if (maxTemp > 0) { maxTempPrefix = "+"; }
while (lampoInput <= max) {
Scanner syote = new Scanner(System.in);
System.out.printf("Syötä mittaus %d/%d: ", lampoInput, max);
try {
int lampotila = syote.nextInt();
if (lampotila < minTemp || lampotila > maxTemp) {
// stderr should be used, but we print to stdout
System.out.printf(
"Anna lämpötila väliltä %s%d - %s%d!\n",
minTempPrefix, minTemp,
maxTempPrefix, maxTemp
);
continue;
} else {
lampotilatMars[i] = lampoInput;
lampoSumma += lampotila;
if (lampotila < pienin) { pienin = lampotila; }
if (lampotila > suurin) { suurin = lampotila; }
}
} catch (NumberFormatException | InputMismatchException e) {
// stderr should be used, but we print to stdout
System.out.println("Antamasi syöte ei ole kokonaisluku");
continue;
}
lampoInput++; i++;
}
System.out.printf(
"Mittausten keskiarvo: %s\n" + "Pienin mittaustulos: %d\n" + "Suurin mittaustulos: %d\n",
(double)lampoSumma / lampotilatMars.length,
pienin,
suurin
);
}
}
```

+ 86
- 0
7_methods/1_TulostaRajatut.md View File

@ -0,0 +1,86 @@
Täydennä tehtäväpohjassa oleva metodi public static void tulostaRajatutLuvut(ArrayList<Integer> luvut, int alaraja, int ylaraja). Metodin tulee tulostaa parametrina annetulta listalta ne luvut, joiden arvot ovat välillä [alaraja, ylaraja]. Alla on muutama esimerkki metodin toiminnasta:
```
ArrayList<Integer> luvut = new ArrayList<>();
luvut.add(3);
luvut.add(2);
luvut.add(6);
luvut.add(-1);
luvut.add(5);
luvut.add(1);
System.out.println("Luvut välillä [0, 5]");
tulostaRajatutLuvut(luvut, 0, 5);
System.out.println("Luvut välillä [3, 10]");
tulostaRajatutLuvut(luvut, 3, 10);
```
```
Esimerkkitulostus:
Luvut välillä [0, 5]
3
2
5
1
Luvut välillä [3, 10]
3
6
5
```
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava15/TulostaRajatut.java
```
Example output:
Luvut välillä [0, 5]
3
2
5
1
Luvut välillä [3, 10]
3
6
5
```
--------------------
**TulostaRajatut.java**
```
// Ref: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava15/TulostaRajatut.java
import java.util.ArrayList;
public class TulostaRajatut {
public static void main(String[] args) {
ArrayList<Integer> luvut = new ArrayList<>();
luvut.add(3);
luvut.add(2);
luvut.add(6);
luvut.add(-1);
luvut.add(5);
luvut.add(1);
System.out.println("Luvut välillä [0, 5]");
tulostaRajatutLuvut(luvut, 0, 5);
System.out.println("Luvut välillä [3, 10]");
tulostaRajatutLuvut(luvut, 3, 10);
}
public static void tulostaRajatutLuvut(ArrayList<Integer> luvut, int alaraja, int ylaraja) {
int i = 0;
while (i < luvut.size() ) {
if (luvut.get(i) >= alaraja && luvut.get(i) <= ylaraja) {
System.out.println(luvut.get(i));
}
i++;
}
}
}
```

+ 67
- 0
7_methods/2_Summa.md View File

@ -0,0 +1,67 @@
Luo tehtäväpohjaan metodi public static int summa(ArrayList<Integer> luvut). Metodin tulee palauttaa parametrina annetun listan lukujen summa.
Metodisi tulee toimia seuraavan esimerkin mukaisesti:
```
ArrayList<Integer> luvut = new ArrayList<>();
luvut.add(3);
luvut.add(2);
luvut.add(6);
luvut.add(-1);
System.out.println(summa(luvut));
luvut.add(5);
luvut.add(1);
System.out.println(summa(luvut));
```
```
Esimerkkitulostus:
10
16
```
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava16/Summa.java
```
Example output:
10
16
```
--------------------
**Summa.java**
```
// Ref: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava16/Summa.java
import java.util.ArrayList;
public class Summa {
public static void main(String[] args) {
ArrayList<Integer> luvut = new ArrayList<>();
luvut.add(3);
luvut.add(2);
luvut.add(6);
luvut.add(-1);
System.out.println(summa(luvut));
luvut.add(5);
luvut.add(1);
System.out.println(summa(luvut));
}
public static int summa(ArrayList<Integer> luvut) {
int i = 0, summa = 0;
while (i < luvut.size()) {
summa += luvut.get(i);
i++;
}
return summa;
}
}
```

+ 66
- 0
7_methods/3_PoistaViimeinen.md View File

@ -0,0 +1,66 @@
Luo tehtäväpohjaan metodi public static void poistaViimeinen(ArrayList<String> mjonot). Metodin tulee poistaa parametrina saadusta listasta viimeisin arvo. Mikäli lista on tyhjä, metodin ei tule tehdä mitään.
Metodisi tulee toimia seuraavan esimerkin mukaisesti:
```
ArrayList<String> merkkijonot = new ArrayList<>();
merkkijonot.add("Eka");
merkkijonot.add("Toka");
merkkijonot.add("Kolmas");
System.out.println(merkkijonot);
poistaViimeinen(merkkijonot);
poistaViimeinen(merkkijonot);
System.out.println(merkkijonot);
```
```
Esimerkkitulostus:
[Eka, Toka, Kolmas]
[Eka]
```
Pohja: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava17/PoistaViimeinen.java
```
Example output:
[Eka, Toka, Kolmas]
[Eka]
```
--------------------
**PoistaViimeinen.java**
```
// Ref: https://github.com/swd1tn002/mooc.fi-2019-osa3/blob/master/src/tehtava17/PoistaViimeinen.java
import java.util.ArrayList;
public class PoistaViimeinen {
public static void main(String[] args) {
ArrayList<String> merkkijonot = new ArrayList<>();
merkkijonot.add("Eka");
merkkijonot.add("Toka");
merkkijonot.add("Kolmas");
System.out.println(merkkijonot);
poistaViimeinen(merkkijonot);
poistaViimeinen(merkkijonot);
System.out.println(merkkijonot);
}
public static void poistaViimeinen(ArrayList<String> mjonot) {
if (mjonot.size() > 0) {
mjonot.remove(mjonot.size() - 1);
}
}
}
```

+ 52
- 0
7_methods/4_Laskuoperaatiot.md View File

@ -0,0 +1,52 @@
Kirjoita luokka Laskuoperaatiot ja siihen kaksi julkista staattista metodia: summa ja erotus. Määrittele metodit siten, että ne saavat parametriarvoinaan 2 double-tyyppistä liukulukua ja että ne palauttavat tuloksena double-tyyppisen liukuluvun. Summa-metodin täytyy palauttaa annettujen lukujen summa ja erotus vastaavasti palauttaa erotuksen (ensimmäinen luku - toinen luku). Huomaa, että et saa tulostaa näissä metodeissa mitään, vaan tulos on palautettava pois metodista.
Voit testata kirjoittamaasi luokkaa alla olevan testiluokan avulla tai kirjoittaa vapaavalintaisen oman testiluokan. Käyttäessäsi valmista testiluokkaa, tallenna se itsellesi tiedostoon LaskuoperaatiotTest.java. Testiluokkaa ei tarvitse palauttaa, vaan koodisi tarkastetaan Viopessa valmiiksi olevalla tarkastimella.
```
public class LaskuoperaatiotTest {
public static void main(String[] args) {
double eka = 9.0;
double toka = 3.0;
System.out.println("Suoritetaan testi arvoilla " + eka + " ja " + toka + ":\n");
double summa = Laskuoperaatiot.summa(eka, toka);
System.out.println(eka + " + " + toka + " = " + summa);
double erotus = Laskuoperaatiot.erotus(eka, toka);
System.out.println(eka + " - " + toka + " = " + erotus);
}
}
```
```
Example output:
Suoritetaan testi arvoilla 9.0 ja 3.0:
9.0 + 3.0 = 12.0
9.0 - 3.0 = 6.0
```
--------------------
**Laskuoperaatiot.java**
```
public class Laskuoperaatiot {
public static void main(String[] args) {
double eka = 9.0;
double toka = 3.0;
System.out.println("Suoritetaan testi arvoilla " + eka + " ja " + toka + ":\n");
double summa = Laskuoperaatiot.summa(eka, toka);
System.out.println(eka + " + " + toka + " = " + summa);
double erotus = Laskuoperaatiot.erotus(eka, toka);
System.out.println(eka + " - " + toka + " = " + erotus);
}
public static double summa(double eka, double toka) { return (eka + toka); }
public static double erotus(double eka, double toka) { return (eka - toka); }
}
```

+ 118
- 0
7_methods/5_Numerot.md View File

@ -0,0 +1,118 @@
Tässä tehtävässä sinun tulee kirjoittaa luokka Numerot. Luokassa on oltava seuraavaksi kuvaillut metodit täsmälleen sellaisina kuin ne on esitetty.
public static int pienin(List<Integer> arvot)
Kirjoita metodi "pienin", joka ottaa parametrinaan listan kokonaislukuja (Integer) ja palauttaa pienimmän listalla esiintyvän kokonaisluvun.
public static int suurin(List<Integer> arvot)
Kirjoita metodi "suurin", joka ottaa parametrinaan listan kokonaislukuja (Integer) ja palauttaa suurimman listalla esiintyvän kokonaisluvun.
public static int summa(List<Integer> arvot)
Kirjoita metodi "summa", joka ottaa parametrinaan listan kokonaislukuja (Integer) ja palauttaa sen arvojen summan. Jos metodille annettu lista on tyhjä (pituus on 0), metodin tulee palauttaa summaksi 0.
Kirjoita myös main-metodi, jossa kokeilet haluamallasi tavalla, että kirjoittamasi metodit toimivat oikein. Voit kirjoittaa main-metodin samaan Numerot-luokkaan tai vaihtoehtoisesti myös erilliseen luokkaan, jota ei tarvitse palauttaa.
HUOM! Tässä tehtävässä main-metodisi saa tulostaa mitä tahansa, mutta pienin, suurin ja summa -metodit eivät saa tulostaa mitään. Metodit eivät saa myöskään muuttaa parametrina annettua listaa. Arviointi ei perustu kirjoittamaasi main-metodiin, vaan erilliseen valmiiksi kirjoitettuun testiluokkaan.
```
Example output:
## Testi 1 ##
Muodostetaan lista: [3, 42, 23, 98]
Listan pienin arvo on: 3
Listan suurin arvo on: 98
Listan arvojen summa on: 166
## Testi 2 ##
Muodostetaan lista: [98, 42, 5, 1, -70]
Listan pienin arvo on: -70
Listan suurin arvo on: 98
Listan arvojen summa on: 76
```
--------------------
**Numerot.java**
```
import java.util.ArrayList;
import java.util.List;
public class Numerot {
public static void main(String[] args) {
List<Integer> lukulista = new ArrayList<Integer>();
lukulista.add(3);
lukulista.add(42);
lukulista.add(23);
lukulista.add(98);
Numerot.muodostaLista(1, lukulista);
//
lukulista.clear();
lukulista.add(98);
lukulista.add(42);
lukulista.add(5);
lukulista.add(1);
lukulista.add(-70);
Numerot.muodostaLista(2, lukulista);
}
public static void muodostaLista(int num, List<Integer> listaLuvut) {
System.out.printf("## Testi %d ##\n\n", num);
System.out.printf("Muodostetaan lista: %s\n", listaLuvut);
int pienin = Numerot.pienin(listaLuvut);
int suurin = Numerot.suurin(listaLuvut);
int summa = Numerot.summa(listaLuvut);
System.out.printf(
"Listan pienin arvo on: %d\n" +
"Listan suurin arvo on: %d\n" +
"Listan arvojen summa on: %d\n\n",
pienin, suurin, summa
);
}
public static int pienin(List<Integer> arvot) {
int i = 0, min = arvot.get(0);
while (i < arvot.size()) {
if (min > arvot.get(i)) {
min = arvot.get(i);
}
i++;
}
return min;
}
public static int suurin(List<Integer> arvot) {
int i = 0, max = arvot.get(0);
while (i < arvot.size()) {
if (max < arvot.get(i)) {
max = arvot.get(i);
}
i++;
}
return max;
}
public static int summa(List<Integer> arvot) {
int i = 0, sum = 0;
while (i < arvot.size()) {
sum += arvot.get(i);
i++;
}
return sum;
}
}
```

+ 67
- 0
8_lottery_bonus/1_Leikkaus.md View File

@ -0,0 +1,67 @@
"Leikkaus on joukko-opin käsite. Joukkojen A ja B leikkaus sisältää kaikki ne alkiot, jotka kuuluvat sekä joukkoon A että joukkoon B. Joukkojen A ja B leikkausta merkitään A ∩ B." (Wikipedia)
Tässä tehtävässä sinun tulee kirjoittaa luokka Leikkaus. Leikkaus-luokassa on oltava laskeLeikkaus-niminen metodi täsmälleen seuraavan kuvauksen mukaisena:
- metodi on julkinen
- metodi on staattinen eli luokkametodi
- metodi palauttaa uuden listan, joka on tyyppiä List<Integer>
- metodi saa parametriarvoinaan kaksi kokonaislukulistaa (List<Integer>)
- metodi palauttaa leikkauksen kahdesta annetusta listasta, eli sellaisen listan, joka sisältää kaikki sellaiset luvut, jotka ovat molemmissa parametriarvoina saaduissa listoissa
- kukin luku saa esiintyä leikkauksessa korkeintaan kerran
- leikkauksen lukujen järjestyksellä ei ole merkitystä.
Kirjoita myös main-metodi, jossa kokeilet haluamallasi tavalla, että kirjoittamasi koodi toimii oikein. Tässä tehtävässä main-metodisi saa tulostaa mitä tahansa. Tehtävän tarkastus ei perustu kirjoittamaasi main-metodiin, vaan erilliseen valmiiksi kirjoitettuun testiluokkaan.
```
Example output:
Lista A: [-70, 120, 98, 1, 789]
Lista B: [98, 42, 5, 1, -70]
Listojen A ja B leikkaus: [-70, 1, 98]
```
--------------------
**Leikkaus.java**
```
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Leikkaus {
public static void main(String[] args) {
List<Integer> listaA = List.of(-70, 120, 98, 1, 789);
List<Integer> listaB = List.of(98, 42, 5, 1, -70, 98);
System.out.printf(
"Listojen A ja B leikkaus: %s\n",
Leikkaus.laskeLeikkaus(listaA, listaB)
);
}
public static List<Integer> laskeLeikkaus(List<Integer> ekaLista, List<Integer> tokaLista) {
List<Integer> leikkausLista = new ArrayList<Integer>();
int i = 0;
// Intersection
while (i < ekaLista.size()) {
int a = 0;
while (a < tokaLista.size()) {
// Get common values if leikkausLista does not contain the value already
if (ekaLista.get(i) == tokaLista.get(a) && !leikkausLista.contains(tokaLista.get(a))) {
leikkausLista.add(tokaLista.get(a));
}
a++;
}
i++;
}
Collections.sort(leikkausLista);
return leikkausLista;
}
}
```

+ 223
- 0
8_lottery_bonus/2_Lotto.md View File

@ -0,0 +1,223 @@
Kirjoita ohjelma Lotto, joka hyödyntää aikaisemmassa tehtävässä kirjoittamaasi Leikkaus-luokkaa.
Ohjelmasi tulee ensin pyytää käyttäjältä oikea rivi sekä lisänumero ja niiden jälkeen käyttäjän oma lottorivi. Oikea rivi ja lisänumero syötetään samalle riville välilyönneillä eroteltuina.
Ohjelmasi tehtävä on tarkastaa, kuinka monta numeroa käyttäjän riviltä osui oikeisiin numeroihin ja osuiko lisänumero. Hyödynnä osumien laskemisessa Leikkaus-luokan laskeLeikkaus-metodia ja lisänumeron tarkastamisessa listan contains-metodia.
Tulosta lopputulos muodossa "N oikein ja lisänumero." tai "N oikein." riippuen siitä, osuiko lisänumero käyttäjän riviin.
✂ Sinun ei tarvitse erikseen palauttaa Leikkaus-luokkaa, se löytyy Viopesta valmiina. Huomaa että tässä tehtävässä Leikkaus-luokalle ei ole määritetty pakettia, eli se on tavallaan samassa paketissa toteuttamasi Lotto-luokan kanssa. Poista siis mahdollinen import-komento, mikäli olet omassa kehitysympäristössäsi sijoittanut nämä kaksi luokkaa eri paketteihin. ✂
```
Example output:
Anna oikea rivi (7 numeroa + lisänumero): 4 12 14 17 23 33 35 8
Anna tarkastettava rivi (7 numeroa): 4 6 7 8 12 16 28
2 oikein ja lisänumero.
```
--------------------
**Lotto.java**
1) Hakee Leikkaus -luokan ulkopuolelta (Viopessa automaattisesti, ei käytetä importia)
```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Lotto {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int oikeaMaxNumCount = 8;
int arvausMaxNumCount = 7;
System.out.print("Anna oikea rivi (7 numeroa + lisänumero): ");
String riviOikea = syote.nextLine();
List<Integer> riviOikeaInt = Lotto.tarkistaSyote(oikeaMaxNumCount, riviOikea);
System.out.print("Anna tarkastettava rivi (7 numeroa): ");
String riviArvaus = syote.nextLine();
List<Integer> riviArvausInt = Lotto.tarkistaSyote(arvausMaxNumCount, riviArvaus);
int i = 0;
List<Integer> riviOikeaIntEqualSize = new ArrayList<Integer>();
while (i < arvausMaxNumCount) {
riviOikeaIntEqualSize.add(riviOikeaInt.get(i));
i++;
}
List<Integer> leikkausLista = Leikkaus.laskeLeikkaus(
riviOikeaIntEqualSize,
riviArvausInt
);
// if riviArvausInt contains extra number (lisänumero) defined as the last value in riviOikeaInt
if (riviArvausInt.contains(riviOikeaInt.get(oikeaMaxNumCount - 1))) {
System.out.printf("%d oikein ja lisänumero.", leikkausLista.size());
} else {
System.out.printf("%d oikein.", leikkausLista.size());
}
}
private static List<Integer> tarkistaSyote(int luvutMaxCount, String numeroListaStr) {
int i = 0;
int lottoMin = 1;
int lottoMax = 42;
List<Integer> numeroLista = new ArrayList<Integer>();
List<String> numeroListaRaw = Arrays.asList(numeroListaStr.split(" "));
if ( numeroListaRaw.size() != luvutMaxCount) {
System.err.printf("Väärä määrä syötettyjä arvoja (sallittu: %d, syötetty: %d)",
luvutMaxCount, numeroListaRaw.size()
);
System.exit(1);
}
while (i < numeroListaRaw.size()) {
try {
int numero = Integer.parseInt(numeroListaRaw.get(i));
if (numero < lottoMin || numero > lottoMax) {
System.err.printf(
"Syötetty arvo %d ei ole hyväksyllä arvovälillä %d - %d.\n",
numero, lottoMin, lottoMax
);
}
numeroLista.add(numero);
} catch (NumberFormatException e) {
System.err.printf("Syötetty arvo %s ei ole kokonaisluku\n", numeroListaRaw.get(i));
System.exit(1);
}
i++;
}
return numeroLista;
}
}
```
/* ---------- ---------- */
**Lotto.java**
2) Sisältää integroidun/optimoidun leikkaus-luokan
```
public class Lotto {
public static void main(String[] args) {
Scanner syote = new Scanner(System.in);
int oikeaMaxNumCount = 8;
int arvausMaxNumCount = 7;
System.out.print("Anna oikea rivi (7 numeroa + lisänumero): ");
String riviOikea = syote.nextLine();
List<Integer> riviOikeaInt = Lotto.tarkistaSyote(oikeaMaxNumCount, riviOikea);
System.out.print("Anna tarkastettava rivi (7 numeroa): ");
String riviArvaus = syote.nextLine();
List<Integer> riviArvausInt = Lotto.tarkistaSyote(arvausMaxNumCount, riviArvaus);
int i = 0;
List<Integer> riviOikeaIntEqualSize = new ArrayList<Integer>();
while (i < arvausMaxNumCount) {
riviOikeaIntEqualSize.add(riviOikeaInt.get(i));
i++;
}
List<Integer> leikkausLista = Leikkaus.laskeLeikkaus(
riviOikeaIntEqualSize,
riviArvausInt
);
// if riviArvausInt contains extra number (lisänumero) defined as the last value in riviOikeaInt
if (riviArvausInt.contains(riviOikeaInt.get(oikeaMaxNumCount - 1))) {
System.out.printf("%d oikein ja lisänumero.", leikkausLista.size());
} else {
System.out.printf("%d oikein.", leikkausLista.size());
}
}
private static List<Integer> tarkistaSyote(int luvutMaxCount, String numeroListaStr) {
int i = 0;
int lottoMin = 1;
int lottoMax = 42;
List<Integer> numeroLista = new ArrayList<Integer>();
List<String> numeroListaRaw = Arrays.asList(numeroListaStr.split(" "));
if ( numeroListaRaw.size() != luvutMaxCount) {
System.err.printf("Väärä määrä syötettyjä arvoja (sallittu: %d, syötetty: %d)",
luvutMaxCount, numeroListaRaw.size()
);
System.exit(1);
}
while (i < numeroListaRaw.size()) {
try {
int numero = Integer.parseInt(numeroListaRaw.get(i));
if (numero < lottoMin || numero > lottoMax) {
System.err.printf(
"Syötetty arvo %d ei ole hyväksyllä arvovälillä %d - %d.\n",
numero, lottoMin, lottoMax
);
}
numeroLista.add(numero);
} catch (NumberFormatException e) {
System.err.printf("Syötetty arvo %s ei ole kokonaisluku\n", numeroListaRaw.get(i));
System.exit(1);
}
i++;
}
return numeroLista;
}
/*
* public static PrintStream laskeLeikkaus(List<Integer> ekaLista, List<Integer> tokaLista) {
*
* List<Integer> leikkausLista = new ArrayList<Integer>();
* int i = 0;
*
* // Intersection, exclude extra number (lisänumero)
* while (i < ( ekaLista.size() - 1)) {
* int a = 0;
* while (a < tokaLista.size()) {
*
* // Get common values if leikkausLista does not contain the value already
* if (ekaLista.get(i) == tokaLista.get(a) && !leikkausLista.contains(tokaLista.get(a))) {
* leikkausLista.add(tokaLista.get(a));
}
a++;
}
i++;
}
Collections.sort(leikkausLista);
// if tokaLista contains extra number (lisänumero) defined as the last value in ekaLista
if (tokaLista.contains(ekaLista.get(ekaLista.size() - 1))) {
return System.out.printf("%d oikein ja lisänumero.", leikkausLista.size());
} else {
return System.out.printf("%d oikein.", leikkausLista.size());
}
```

+ 37
- 0
9_clitools/1_Erapaiva.md View File

@ -0,0 +1,37 @@
Tee ohjelma Erapaiva, joka kertoo laskun päivämäärän perusteella eräpäivän. Eräpäivä on 14 päivän päästä laskun päivämäärästä. Tutustu LocalDate luokan plusDays metodiin.
```
Example output:
Anna laskun päivämäärä (vvvv-kk-pp): 2019-12-24
Eräpäivä on 2020-01-07
```
------------------
**Erapaiva.java**
```
import java.time.DateTimeException;
import java.time.format.DateTimeFormatter;
import java.time.LocalDate;
import java.util.Scanner;
public class Erapaiva {
public static void main(String[] args) {
DateTimeFormatter pvmMuoto = DateTimeFormatter.ofPattern("yyyy-MM-dd");
Scanner syote = new Scanner(System.in);
System.out.print("Anna laskun päivämäärä (vvvv-kk-pp): ");
try {
LocalDate pvmLasku = LocalDate.parse(syote.next(), pvmMuoto);
LocalDate pvmErapaiva = pvmLasku.plusDays(14);
System.out.printf("Eräpäivä on %s", pvmErapaiva);
} catch (DateTimeException e) {
System.err.println("Syötä päivämäärä muodossa vvvv-kk-pp");
System.exit(1);
}
}
}
```

+ 44
- 2
README.md View File

@ -1,3 +1,45 @@
# java-basics
# Java basics
Java fundamentals through coding exercises
Java fundamentals through coding exercises
## Contents
- [Basics]()
- Description:
- [Conditionals]()
- Description:
- [Loops]()
- Description:
- [Strings]()
- Description:
- [Lists]()
- Description:
- [Tables]()
- Description:
- [Methods]()
- Description:
- [Lottery]()
- Description:
- [Command line tools]()
- Description:
- [Classes and objects]()
- Description:

Write Preview
|||||||
|||||||
xxxxxxxxxx
 
​
000:0
​x
 
​
000:0
Loading…
Cancel
Save