.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.fx.ide.jdt.core.JAVAFX_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/ohj2"/>
+	<classpathentry kind="lib" path="jar/Tietorakenne.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Kirjalista</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	    <buildCommand>
+            <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+            <arguments>
+            </arguments>
+        </buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

build.fxbuild

+<?xml version="1.0" encoding="ASCII"?>
+<anttasks:AntTask xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:anttasks="http://org.eclipse.fx.ide.jdt/1.0" buildDirectory="${project}/build">
+  <deploy>
+    <application name="Kirjalista"/>
+    <info/>
+  </deploy>
+  <signjar/>
+</anttasks:AntTask>

build.xml

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project default="create_run_jar" name="Create Runnable Jar for Project Kirjalista">
+    <!--this file was created by Eclipse Runnable JAR Export Wizard-->
+    <!--ANT 1.7 is required                                        -->
+    <!--define folder properties-->
+    <property name="dir.buildfile" value="."/>
+    <property name="dir.workspace" value="C:/kurssit/ohj2/ws"/>
+    <property name="dir.jarfile" value="${dir.buildfile}"/>
+    <target name="create_run_jar">
+        <jar destfile="${dir.jarfile}/Kirjalista.jar" filesetmanifest="mergewithoutmain">
+            <manifest>
+                <attribute name="Main-Class" value="fxKirjalista.KirjalistaMain"/>
+                <attribute name="Class-Path" value="."/>
+            </manifest>
+            <fileset dir="${dir.jarfile}/bin"/>
+            <zipfileset excludes="META-INF/*.SF" src="C:/devel/ec2412/eclipse/plugins/org.eclipse.fx.ide.css.jfx8_3.8.0.202204150904.jar"/>
+            <zipfileset excludes="META-INF/*.SF" src="C:/devel/jar/Ali.jar"/>
+            <zipfileset excludes="META-INF/*.SF" src="C:/devel/jar/fxgui.jar"/>
+            <zipfileset excludes="META-INF/*.SF" src="C:/devel/jar/Graphics.jar"/>
+            <zipfileset excludes="META-INF/*.SF" src="C:/Users/omistaja/Ohjelmointi/Java-projektit/Jarreja/Tietorakenne.jar"/>
+        </jar>
+    </target>
+</project>

src/Kirjalista/Genre.java

+package Kirjalista;
+
+import java.io.PrintStream;
+import java.util.Random;
+
+import fi.jyu.mit.ohj2.Mjonot;
+
+/**
+ * Genre-luokka
+ * - Sisältää genren tiedot
+ * - Muuttaa merkkijonon genren tiedoiksi
+ * - Muuttaa genren tiedot merkkijonoksi
+ */
+public class Genre {
+    
+    private int id = 0;
+    private String nimi = "";
+    
+    private static int seuraavaId = 1;
+    
+    /**
+     * Ottaa merkkijonon ja muuttaa sen genren tiedoiksi, poistaa turhat välilyönnit ja muuttaa
+     * syötteen pieniksi kirjaimiksi
+     * @param mjono Merkkijono, josta genren tiedot saadaan
+     * <pre name="test">
+     * Genre g = new Genre();
+     * g.parse("fantasia");
+     * g.toString() === "0|fantasia";
+     * g.parse("FANTASIA");
+     * g.toString() === "0|fantasia";
+     * g.parse("  Fantasia   ");
+     * g.toString() === "0|fantasia";
+     * g.getNimi() === "fantasia";
+     * </pre>
+     */
+    public void parse(String mjono) {
+        StringBuilder sb = new StringBuilder(mjono.trim());
+        this.nimi = Mjonot.erota(sb, '|', true).toLowerCase();
+    }
+    
+    
+    /**
+     * Lukee tiedot tiedostosta. Ei voi käyttää ylläolevaa samaan, koska id:n kanssa tulisi ongelmia
+     * 
+     * Ottaa merkkijonon ja muuttaa sen genren tiedoiksi, poistaa turhat välilyönnit ja muuttaa
+     * syötteen pieniksi kirjaimiksi
+     * @param rivi Merkkijono, josta genren tiedot saadaan
+     * <pre name="test">
+     * Genre g = new Genre();
+     * g.parseTiedostosta("1|fantasia");
+     * g.toString() === "1|fantasia";
+     * g.parseTiedostosta("   01|   FANTASIA   ");
+     * g.toString() === "1|fantasia";
+     * g.parseTiedostosta("1|  Fantasia   ");
+     * g.toString() === "1|fantasia";
+     * </pre>
+     */
+    public void parseTiedostosta(String rivi) {
+        StringBuilder sb = new StringBuilder(rivi);
+        this.id = Mjonot.erota(sb, '|', 0);
+        seuraavaId = this.id + 1;
+        this.nimi = sb.toString().trim().toLowerCase();
+    }
+    
+    
+    /**
+     * Palauttaa genren nimen merkkijonona
+     */
+    @Override
+    public String toString() {
+        return this.id + "|" + this.nimi;
+    }
+    
+    
+    /**
+     * Rekisteröi genren antamalla sille id:n, kasvattaa seuraavaId:tä
+     * <pre name="test">
+     *  Genre g1 = new Genre();
+     *  Genre g2 = new Genre();
+     *  g1.rekisteroi();
+     *  g2.rekisteroi();
+     *  g1.getId() === g2.getId() - 1;
+     *  </pre>
+     */
+    public void rekisteroi() {
+        this.id = seuraavaId;
+        seuraavaId++;
+    }
+    
+    
+    
+    private String[] esim = {"Fantasia", "Sci-fi", "Kauhu"};
+    /**
+     * Asettaa genreksi jonkun ylläolevista
+     * TODO poista
+     */
+    public void esimerkkiGenre() {
+        Random rand = new Random();
+        this.nimi = esim[rand.nextInt(3)];
+    }
+    
+    /**
+     * Luo olion testejä varten
+     * @return Genre satunnaisilla arvoilla
+     */
+    public static Genre testiGenre() {
+        Genre g = new Genre();
+        Random rand = new Random();
+        g.nimi = g.esim[rand.nextInt(3)];
+        g.rekisteroi();
+        return g;
+    }
+    
+    /**
+     * Palauttaa genren nimen
+     * @return Genren nimi
+     */
+    public String getNimi() {
+        return this.nimi;
+    }
+    
+    /**
+     * Palauttaa genren id:n
+     * @return Genren id
+     */
+    public int getId() {
+        return this.id;
+    }
+    
+    
+    /**
+     * Tulostaa genren tiedot
+     * @param out Tietovirta johon tulostetaan
+     */
+    public void tulosta(PrintStream out) {
+        out.println(this.id + " " + this.nimi);
+    }
+
+
+    /**
+     * Asettaa id:lle annetun arvon
+     * @param id arvo, joka asetetaan id:ksi
+     * Tämä olemassa, koska tietyllä genrellä on aina tietty id ja ilman tätä aliohjelmaa tulisi
+     * ongelmia sellaisten lisättyjen kirjojen kanssa, joiden genre on jo "tietokannassa." Ilman tätä
+     * kyseisten genrejen id olisi 0 ja ohjelma ei osaisi hakea niitä
+     */
+    public void setId(int id) {
+        this.id = id;
+    }
+
+
+}

src/Kirjalista/GenreRelaatio.java

+package Kirjalista;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+import tietorakenne.LinkattuLista;
+
+
+/**
+ * Genren ja kirjan välinen relaatio
+ * - pitää kirjaa liimatuista genreistä ja kirjoista
+ * - palauttaa kirjojen id:t genren id:n perusteella
+ * - palauttaa genrejen id:t kirjan id:n perusteella
+ * - lukee ja kirjoittaa tiedostoon
+ */
+public class GenreRelaatio {
+    private LinkattuLista<KirjanGenre> alkiot = new LinkattuLista<KirjanGenre>();
+    private static boolean muutettu = false;
+    
+    /**
+     * Lisää listaan alkion
+     * @param alkio Alkio, joka lisätään listaan
+     */
+    public void lisaa(KirjanGenre alkio) {
+        alkiot.lisaa(alkio);
+        muutettu = true;
+    }
+    
+    
+    /**
+     * Palauttaa ArrayListin kirjojen id:istä, joilla on tietty genreid
+     * esim. palauttaa kaikkien kirjojen id:t, joiden genre on fantasia
+     * @param genreId Genren id, jonka perusteella haetaan kirjojen id:itä
+     * @return Kaikkien niiden kirjojen id:t, joiden genren id on genreId 
+     * <pre name="test">
+     * #import java.util.ArrayList;
+     * GenreRelaatio gr = new GenreRelaatio();
+     * Kirja k = Kirja.testiKirja();
+     * Kirja k1 = Kirja.testiKirja();
+     * Kirja k2 = Kirja.testiKirja();
+     * Genre g = Genre.testiGenre();
+     * Genre g2 = Genre.testiGenre(); 
+     * 
+	 * gr.lisaa(new KirjanGenre(k, g));
+	 * gr.lisaa(new KirjanGenre(k1, g));
+	 * gr.lisaa(new KirjanGenre(k2, g));
+	 * gr.lisaa(new KirjanGenre(k, g2));
+	 * ArrayList<Integer> al = gr.haeKirjat(g.getId());
+	 * int i = al.get(0);
+	 * int i1 = al.get(1);
+	 * int i2 = al.get(2);
+	 * i === k.getId();	  
+	 * i1 === k1.getId();	 
+	 * i2 === k2.getId();
+	 * al.size() === 3;
+	 
+	 * </pre>
+     */
+    public ArrayList<Integer> haeKirjat(int genreId) {
+        
+        ArrayList<Integer> kirjojenIdt = new ArrayList<Integer>();
+        
+        alkiot.iter = alkiot.getEka();
+        
+        for (int i = 0; i < alkiot.length(); i++) {
+            KirjanGenre alkio = alkiot.iter.getSisalto();
+            if (alkio.getGenreId() == genreId) {
+                kirjojenIdt.add(alkio.getKirjaId());
+            }
+            alkiot.iter = alkiot.iter.getNext();
+        }
+        
+        return kirjojenIdt;
+    }
+    
+    
+    /**
+     * Palauttaa ArrayListin genrejen id:istä, joilla on tietty kirjaid
+     * eli toisin sanoen palauttaa tietyn kirjan kaikkien genrejen id:t
+     * @param kirjaId Kirjan id, jonka perusteella haetaan genrejen id:itä
+     * @return Kaikkien niiden genrejen id:t, joiden kirjan id on kirjaId 
+     * <pre name="test">
+     * GenreRelaatio gr = new GenreRelaatio();
+     * Kirja k = Kirja.testiKirja();
+     * Kirja k2 = Kirja.testiKirja();
+     * Genre g = Genre.testiGenre();
+     * Genre g1 = Genre.testiGenre();
+     * Genre g2 = Genre.testiGenre(); 
+     * 
+     * gr.lisaa(new KirjanGenre(k, g2));
+     * gr.lisaa(new KirjanGenre(k, g));
+     * gr.lisaa(new KirjanGenre(k, g1));
+     * gr.lisaa(new KirjanGenre(k2, g));
+     * ArrayList<Integer> al = gr.haeGenret(k.getId());
+     * int i = al.get(0);
+     * int i1 = al.get(1);
+     * int i2 = al.get(2);
+     * i === g2.getId();   
+     * i1 === g.getId();     
+     * i2 === g1.getId();
+     * 
+     * al.size() === 3; 
+     * </pre>
+     */
+    public ArrayList<Integer> haeGenret(int kirjaId) {
+
+        ArrayList<Integer> genrejenIdt = new ArrayList<Integer>();
+        
+        alkiot.iter = alkiot.getEka();
+        
+        for (int i = 0; i < alkiot.length(); i++) {
+            KirjanGenre alkio = alkiot.iter.getSisalto();
+            if (alkio.getKirjaId() == kirjaId) {
+                genrejenIdt.add(alkio.getGenreId());
+            }
+            alkiot.iter = alkiot.iter.getNext();
+        }
+        
+        return genrejenIdt;
+    }
+    
+    
+    /**
+     * Poistaa alkion, jolla on annettu kirjaid
+     * @param kirjaid kirjan id
+     * <pre name="test">
+     * GenreRelaatio gr = new GenreRelaatio();
+     * Kirja k = Kirja.testiKirja();
+     * Kirja k1 = Kirja.testiKirja();
+     * Kirja k2 = Kirja.testiKirja();
+     * Genre g = Genre.testiGenre(); 
+     * 
+     * gr.lisaa(new KirjanGenre(k, g));
+     * gr.lisaa(new KirjanGenre(k1, g));
+     * gr.lisaa(new KirjanGenre(k2, g));
+     * gr.lisaa(new KirjanGenre(k, g));
+	 * 
+	 * int i1 = gr.haeKirjat(g.getId()).get(0); 
+	 * i1 === k.getId();
+	 * gr.poista(k.getId());  
+	 * i1 = gr.haeKirjat(g.getId()).get(0);
+	 * i1 === k1.getId();
+	 * 
+	 * 
+	 * </pre>
+     */
+    public void poista(int kirjaid) {
+        if (alkiot.length() == 0) return;
+        
+        alkiot.iter = alkiot.getEka();
+        int i = 0;
+        
+        while (i < alkiot.length()) {
+            KirjanGenre kg = alkiot.iter.getSisalto();
+            if (kg.getKirjaId() == kirjaid) {
+                alkiot.poista(i);
+                alkiot.iter = alkiot.iter.getNext();
+                continue;
+            }
+            alkiot.iter = alkiot.iter.getNext();
+            i++;
+        }
+        
+        muutettu = true;
+    }
+
+
+    /**
+     * Lukee tiedostosta genrerelaatiot ja lisää ne listaan
+     */
+    public void lueTiedosto() {
+        
+        try (Scanner fi = new Scanner(new File("tiedostot\\genrerelaatiot.dat"))) {
+            while (fi.hasNextLine()) {
+                String rivi = fi.nextLine();
+                KirjanGenre kg = new KirjanGenre();
+                kg.parse(rivi);
+                this.lisaa(kg);
+            }
+            muutettu = false;
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        } 
+        
+    }
+
+    
+    /**
+     * Kirjoittaa genrelaatioiden tiedot tiedostoon
+     */
+    public void tallenna() {
+        
+        if (!muutettu) return;
+        
+        try (PrintStream fo = new PrintStream(new File("tiedostot\\genrerelaatiot.dat"))) {
+            
+            alkiot.iter = alkiot.getEka();
+            
+            for (int i = 0; i < alkiot.length(); i++, alkiot.iter = alkiot.iter.getNext()) {
+                KirjanGenre kg = alkiot.iter.getSisalto();
+                fo.println(kg);
+            }
+            
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        }
+        
+    }
+}

src/Kirjalista/Genret.java

+package Kirjalista;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+/**
+ * Monikkoluokka genreille
+ * - Sisältää listan genreistä
+ * - Lisää ja poistaa kirjoja
+ * - Lukee ja kirjoittaa tiedostoon
+ * - Etsii ja lajittelee
+ * <pre name="test">
+ * #import java.util.NoSuchElementException;
+ * Genret g = new Genret();
+ * Genre g1 = Genre.testiGenre();
+ * Genre g2 = Genre.testiGenre();
+ * Genre g3 = Genre.testiGenre();
+ * 
+ * g.lisaa(g1);
+ * g.lisaa(g2);
+ * g.lisaa(g3);
+ * 
+ * Genre g4 = new Genre();
+ * g4.parseTiedostosta(g1.toString());
+ * 
+ * g.onOlemassa(g4.getNimi()) === true;
+ * 
+ * g.haeIdNimella(g1.getNimi()) === g1.getId();
+ * g.haeIdNimella(g2.getNimi()) === g2.getId();
+ * g.haeIdNimella(g3.getNimi()) === g3.getId();
+ * 
+ * g.hae(g1.getId()).toString() === g1.getId() + "|" + g1.getNimi();
+ * g.hae(g2.getId()).toString() === g2.getId() + "|" + g2.getNimi();
+ * g.hae(g3.getId()).toString() === g3.getId() + "|" + g3.getNimi(); 
+ * 
+ * int g1Id = g1.getId(); 
+ * g.poista(g1Id);
+ * g.hae(g1Id); #THROWS NoSuchElementException
+ * </pre>
+ */
+public class Genret {
+    
+    private ArrayList<Genre> alkiot = new ArrayList<Genre>();
+    private static boolean muutettu = false;
+    
+    /**
+     * Lisää genren listaan, jos samannimistä genreä ei ole olemassa
+     * @param genre Lisättävä genre
+     * @return true, jos samannimistä genreä ei ole olemassa
+     */
+    public boolean lisaa(Genre genre) {
+        if (onOlemassa(genre.getNimi())) {
+            genre.setId(haeIdNimella(genre.getNimi()));
+            return false;
+        }
+        alkiot.add(genre);
+        muutettu = true;
+        return true;
+    }
+    
+    
+    /**
+     * Hakee genren id:n nimen perusteella
+     * @param nimi Nimi, jonka perusteella id haetaan
+     * @return Genren id, -1 jos ei löydy
+     */
+    public int haeIdNimella(String nimi) {
+        for (int i = 0; i < alkiot.size(); i++) {
+            if (alkiot.get(i).getNimi().toLowerCase().contentEquals(nimi.toLowerCase())) return alkiot.get(i).getId();
+        }
+        return -1;
+    }
+
+
+    /**
+     * Poistaa genren annetulla id:llä
+     * @param id Id, jonka perusteella genre poistetaan
+     */
+    public void poista(int id) {
+        for (int i = 0; i < alkiot.size(); i++) {
+            if (alkiot.get(i).getId() == id) {
+                alkiot.remove(i);
+                muutettu = true;
+                return;
+            }
+        }
+        throw new NoSuchElementException("Genreä id:llä " + id + " ei löydy.");
+        
+        
+    }
+    
+    
+    /**
+     * Tarkistaa, onko tietyn nimistä genreä olemassa
+     * @param nimi Genren nimi
+     * @return True, jos genre on olemassa
+     */
+    public boolean onOlemassa(String nimi) {
+        for (int i = 0; i < alkiot.size(); i++) {
+            if (alkiot.get(i).getNimi().toLowerCase().contentEquals(nimi.toLowerCase())) {
+                return true;
+                
+            }
+        }
+        return false;
+    }
+    
+    
+    /**
+     * Hakee genren nimen id:n perusteella
+     * @param id haettavan genren id
+     * @return Viite genreen halutulla id:llä
+     */
+    public Genre hae(int id) {
+        for (int i = 0; i < alkiot.size(); i++) {
+            if (alkiot.get(i).getId() == id) return alkiot.get(i);
+        }
+        
+        throw new NoSuchElementException("Genreä id:llä " + id + " ei löydy!");
+    }
+
+
+    /**
+     * Lukee tiedostosta genrejen tiedot ja lisää ne listaan
+     */
+    public void lueTiedosto() {
+        
+        try (Scanner fi = new Scanner(new File("tiedostot\\genret.dat"))) {
+            while (fi.hasNextLine()) {
+                String rivi = fi.nextLine();
+                Genre genre = new Genre();
+                genre.parseTiedostosta(rivi);
+                this.lisaa(genre);
+            }
+            muutettu = false;
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        } 
+        
+    }
+
+    /**
+     * Kirjoittaa genrejen tiedot tiedostoon, jos tietoja on muutettu
+     */
+    public void tallenna() {
+        
+        if (!muutettu) return;
+        
+        try (PrintStream fo = new PrintStream(new File("tiedostot\\genret.dat"))) {
+            
+            for (int i = 0; i < alkiot.size(); i++) {
+                fo.println(alkiot.get(i));
+            }
+            
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        }
+        
+    }    
+}

src/Kirjalista/Kirja.java

+package Kirjalista;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Random;
+import fi.jyu.mit.ohj2.Mjonot;
+
+
+/**
+ * Kirja-luokka
+ * - Sisältää kirjan tiedot
+ * - Muuttaa merkkijonon kirjan tiedoiksi
+ * - Muuttaa kirjan tiedot merkkijonoksi
+ */
+public class Kirja {
+    private int id = 0;
+    private String nimi = "";
+    private String kirjoittaja  = "";
+    private String kirjasarja = "";
+    private int julkaisuVuosi = 0; 
+    private int sivumaara = 0;
+    
+    private ArrayList<String> tiedot = new ArrayList<String>();
+    
+    private static int seuraavaId = 1;
+    
+        
+    /**
+     * Ottaa merkkijonon ja muuttaa sen kirjan tiedoiksi, poistaa turhat välilyönnit
+     * merkkijono muotoa nimi|kirjoittaja|kirjasarja|sivumäärä
+     * @param mjono Merkkijono, josta kirjan tiedot saadaan
+     * <pre name="test">
+     * Kirja k = new Kirja();
+     * k.parse("Hobitti|J.R.R. Tolkien||1937|336");
+     * k.toString() === "0|Hobitti|J.R.R. Tolkien||1937|336";
+     * 
+     * Kirja k2 = new Kirja();
+     * k2.parse("    Hobitti  |  J.R.R. Tolkien |   |  1937  |  336");
+     * k2.toString() === "0|Hobitti|J.R.R. Tolkien||1937|336";
+     * 
+     * 
+     * </pre>
+     */
+    public void parse(String mjono) {
+        StringBuilder sb = new StringBuilder(mjono);
+        
+        this.tiedot.removeAll(this.tiedot);
+        
+        this.nimi = Mjonot.erota(sb, '|').trim();
+        this.kirjoittaja = Mjonot.erota(sb, '|').trim();
+        this.kirjasarja = Mjonot.erota(sb, '|').trim();
+        this.julkaisuVuosi = Mjonot.erota(sb, '|', 0);
+        this.sivumaara = Mjonot.erotaInt(sb, 0);
+        
+        this.tiedot.add(this.nimi);
+        this.tiedot.add(this.kirjoittaja);
+        this.tiedot.add(this.kirjasarja);
+        this.tiedot.add(String.valueOf(this.julkaisuVuosi));
+        this.tiedot.add(String.valueOf(this.sivumaara));
+    }
+    
+    
+    /**
+     * Tämä aliohjelma lukee tiedostoon tallennetut tiedot. Ei voi käyttää yllä olevaa samaan, koska id:n 
+     * kanssa tulisi ongelmia
+     * 
+     * Ottaa merkkijonon ja muuttaa sen kirjan tiedoiksi, poistaa turhat välilyönnit
+     * merkkijono muotoa id|nimi|kirjoittaja|kirjasarja|sivumäärä
+     * @param mjono Merkkijono, josta kirjan tiedot saadaan
+     * <pre name="test">
+     * Kirja k = new Kirja();
+     * k.parseTiedostosta("01|Hobitti|J.R.R. Tolkien||1937|336");
+     * k.toString() === "1|Hobitti|J.R.R. Tolkien||1937|336";
+     * 
+     * Kirja k2 = new Kirja();
+     * k2.parseTiedostosta("  2   |    Hobitti  |  J.R.R. Tolkien |   |   1937| 336");
+     * k2.toString() === "2|Hobitti|J.R.R. Tolkien||1937|336";
+     * 
+     * 
+     * </pre>
+     */
+    public void parseTiedostosta(String mjono) {
+        StringBuilder sb = new StringBuilder(mjono);
+        this.id = Mjonot.erota(sb, '|', 0);
+        seuraavaId = this.id + 1;
+        this.nimi = Mjonot.erota(sb, '|').trim();
+        this.kirjoittaja = Mjonot.erota(sb, '|').trim();
+        this.kirjasarja = Mjonot.erota(sb, '|').trim();
+        this.julkaisuVuosi = Mjonot.erota(sb, '|', 0);
+        this.sivumaara = Mjonot.erotaInt(sb, 0);
+        
+        this.tiedot.add(this.nimi);
+        this.tiedot.add(this.kirjoittaja);
+        this.tiedot.add(this.kirjasarja);
+        this.tiedot.add(String.valueOf(this.julkaisuVuosi));
+        this.tiedot.add(String.valueOf(this.sivumaara));
+    }
+    
+    
+    /**
+     * Palauttaa kirjan tiedot merkkijonona muodossa id|nimi|kirjoittaja|kirjasarja|sivumäärä
+     */
+    @Override
+    public String toString() {
+        return (this.id + "|" + this.nimi + "|" + this.kirjoittaja + "|" + this.kirjasarja 
+                + "|" + this.julkaisuVuosi + "|" + this.sivumaara);
+    }
+    
+    
+    /**
+     * Rekisteröi kirjan antamalla sille Id:n. Kasvattaa seuraavaId:tä.
+     *  <pre name="test">
+     *  Kirja k = new Kirja();
+     *  Kirja k2 = new Kirja();
+     *  k.rekisteroi();
+     *  k2.rekisteroi();
+     *  k.getId() === k2.getId() - 1;
+     *  </pre>
+     */
+    public void rekisteroi() {
+        this.id = seuraavaId;
+        seuraavaId++;
+    }
+    
+    
+    /**
+     * Apumetodi, jolla saadaan täytettyä testiarvot kirjalle.
+     */
+    public void esimerkkiKirja() {
+        Random rand = new Random();
+        this.nimi = "Hobitti" + rand.nextInt(10);
+        this.kirjoittaja = "J.R.R. Tolkien";
+        this.kirjasarja = "";
+        this.julkaisuVuosi = 0;
+        this.sivumaara = rand.nextInt(1000);
+    }
+
+    
+    /**
+     * Apumetodi, jolla saadaan luotua kirjaolio testejä varten
+     * @return Kirja satunnaisilla arvoilla
+     */
+    public static Kirja testiKirja() {
+        Kirja k = new Kirja();
+        k.rekisteroi();
+        Random rand = new Random();
+        k.nimi = "Hobitti" + rand.nextInt(10);
+        k.kirjoittaja = "J.R.R. Tolkien";
+        k.kirjasarja = "";
+        k.julkaisuVuosi = 1937;
+        k.sivumaara = rand.nextInt(1000);
+        return k;
+    }
+    
+    /**
+     * @return palauttaa kirjan id:n
+     */
+    public int getId() {
+        return this.id;
+    }
+    
+    /**
+     * @return Kirjan nimi
+     */
+    public String getNimi() {
+        return this.nimi;
+    }
+    
+    /**
+     * Tulostaa kirjan tiedot
+     * @param out Tietovirta, johon tulostetaan
+     */
+    public void tulosta(PrintStream out) {
+        
+        String formaatti = "%s:\n"
+                        + "  Kirjoittanut: %s\n"
+                        + (this.kirjasarja.contentEquals("") ? "%s" : "  Kirjasarja: %s\n")
+                        + "  Julkaisuvuosi: %s\n"
+                        + "  Sivumäärä: %s\n";
+        
+        out.printf(formaatti, this.nimi, this.kirjoittaja, this.kirjasarja, this.julkaisuVuosi, this.sivumaara);
+        
+    }
+    
+    @Override
+    public Kirja clone() {
+        Kirja uusi = new Kirja();
+        uusi.parse(this.toString());
+        return uusi;
+    }
+
+
+    /**
+     * Palauttaa olion tiedot arraylistinä
+     * @return olion tiedot arraylistinä
+     */
+    public ArrayList<String> getTiedot() {
+        return this.tiedot;
+    }
+
+}
+

src/Kirjalista/KirjanGenre.java

+package Kirjalista;
+
+import fi.jyu.mit.ohj2.Mjonot;
+
+/**
+ * Liimaa kirjan ja genren yhteen id:n perusteella
+ */
+public class KirjanGenre {
+    private int kirjaId;
+    private int genreId;
+    
+    
+    /**
+     * Luo olion
+     * @param kirja Kirja
+     * @param genre Genre
+     */
+    public KirjanGenre(Kirja kirja, Genre genre) {
+        this.kirjaId = kirja.getId();
+        this.genreId = genre.getId();
+    }
+    
+    /**
+     * Luo tyhjän olion
+     */
+    public KirjanGenre() {
+    }
+    
+    /**
+     * Palauttaa kirjan id:n
+     * @return Kirjan id
+     */
+    public int getKirjaId() {
+        return this.kirjaId;
+    }
+    
+    
+    
+    /**
+     * Palauttaa genren id:n
+     * @return Genren id
+     */
+    public int getGenreId() {
+        return this.genreId;
+    }
+
+
+    /**
+     * Muuttaa merkkijonon olion tiedoiksi
+     * @param rivi Merkkijono
+     * <pre name="test">
+	 * KirjanGenre kg = new KirjanGenre();
+	 * 
+	 * kg.parse("1|2");  
+	 * kg.toString() === "1|2";
+	 * kg.parse("0|0");  
+	 * kg.toString() === "0|0";
+	 * kg.parse("100|100");  
+	 * kg.toString() === "100|100";
+	 * kg.parse("2|2");  
+	 * kg.toString() === "2|2";
+	 * 
+	 * </pre>
+     */
+    public void parse(String rivi) {
+        StringBuilder sb = new StringBuilder(rivi);
+        this.kirjaId = Mjonot.erota(sb, '|', 0);
+        this.genreId = Mjonot.erotaInt(sb, 0);        
+    }
+    
+    
+    @Override
+    public String toString() {
+        return this.kirjaId + "|" + this.genreId;
+    }
+    
+}
+
+

src/Kirjalista/Kirjasto.java

+package Kirjalista;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+
+/**
+ * Luokka, joka keskustelee käyttöliittymän kanssa 
+ * - Välittää tietoja käyttöliittymän ja kirjojen sekä genrejen välillä
+ */
+public class Kirjasto {
+    private Kirjat kirjat = new Kirjat();
+    private GenreRelaatio genreRelaatio = new GenreRelaatio();
+    private Genret genret = new Genret();
+    
+    
+    
+    /**
+     * @param kirja Lisättävä kirja
+     */
+    public void lisaaKirja(Kirja kirja) {
+        kirja.rekisteroi();
+        kirjat.lisaa(kirja);
+    }
+    
+    
+    /**
+     * Lisää genret, jos sen nimisiä ei vielä ole olemassa
+     * @param genre Lisättävät genret
+     */
+    public void lisaaGenre(Genre[] genre) {
+        for (int i = 0; i < genre.length; i++) {
+            if (genret.lisaa(genre[i])) genre[i].rekisteroi();
+        }
+    }
+    
+    /**
+     * Ottaa taulukollisen genrejä ja liima ne kirjan id:n kanssa yhteen
+     * @param kirja Kirja
+     * @param kirjanGenret Taulukko kaikista kirjan genreistä
+     */
+    public void lisaaGenreRelaatio(Kirja kirja, Genre[] kirjanGenret) {
+        for (int i = 0; i < kirjanGenret.length; i++) {
+            genreRelaatio.lisaa(new KirjanGenre(kirja, kirjanGenret[i])); 
+        }
+    }
+    
+    
+    /**
+     * Poistaa kirjan yhteyden genreihin
+     * @param kirja Kirja
+     */
+    public void poistaGenreRelaatio(Kirja kirja) {
+        genreRelaatio.poista(kirja.getId());
+    }
+    
+    
+    /**
+     * Poistaa annetun kirjan
+     * @param kirja Poistettava kirja
+     */
+    public void poistaKirja(Kirja kirja) {
+        poistaGenreRelaatio(kirja);
+        kirjat.poista(kirja.getId());
+    }
+    
+    /**
+     * @param idnro Haettavan kirjan id
+     * @return Kirja annetussa indeksipaikassa
+     * @throws NoSuchElementException Jos id laiton
+     */
+    public Kirja haeKirja(int idnro) throws NoSuchElementException {
+        return kirjat.hae(idnro);
+    }
+    
+    
+    /**
+     * Hakee taulukon kirjan genreistä kirjan id:n perusteella
+     * @param kirjaId Sen kirjan id, jonka genrejä haetaan
+     * @return Kaikki kirjan genret taulukossa
+     */
+    public Genre[] haeGenret(int kirjaId) {
+        ArrayList<Integer> idt = genreRelaatio.haeGenret(kirjaId);
+        Genre[] palautettava = new Genre[idt.size()];
+        for (int i = 0; i < idt.size(); i++) {
+            palautettava[i] = genret.hae(idt.get(i));
+        }
+        return palautettava;
+    }
+    
+    
+    /**
+     * @return Kirjojen lukumäärä
+     */
+    public int getKirjaLkm() {
+        return this.kirjat.getLkm();
+    }
+
+    
+    /**
+     * Hakee kirjan indeksin perusteella
+     * @param ind Indeksipaikka, josta kirja haetaan
+     * @return Kirja annetussa indeksipaikassa
+     */
+    public Kirja haeKirjaIndeksilla(int ind) {
+        return kirjat.haeIndeksilla(ind);
+    }
+
+    
+    /**
+     * Lukee tiedostosta tiedot
+     * Luo tiedostoille hakemiston, jos se puuttuu
+     */
+    public void lueTiedosto() {
+        
+        File dir = new File("tiedostot");
+        dir.mkdir();
+        
+        this.kirjat = new Kirjat();
+        this.genret = new Genret();
+        this.genreRelaatio = new GenreRelaatio();
+        
+        kirjat.lueTiedosto();
+        genret.lueTiedosto();
+        genreRelaatio.lueTiedosto();
+    }
+
+    
+    /**
+     * Tallentaa tiedot
+     */
+    public void tallenna() {
+       
+        
+        kirjat.tallenna();
+        genret.tallenna();
+        genreRelaatio.tallenna();
+        
+    }
+
+
+}

src/Kirjalista/Kirjat.java

+package Kirjalista;
+
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+import java.io.File;
+
+/**
+ * Monikkoluokka kirjoille.
+ * - Sisältää taulukon kirjoista
+ * - Lisää ja poistaa kirjoja
+ * - Lukee ja kirjoittaa tiedostoon (sitten joskus)
+ * - Etsii ja lajittelee (sitten joskus)
+ * <pre name="test">
+ * #import java.util.NoSuchElementException;
+ * #THROWS NoSuchElementException
+ * Kirjat kirjat = new Kirjat();
+ * 
+ * Kirja k1 = new Kirja();
+ * Kirja k2 = new Kirja();
+ * Kirja k3 = new Kirja();
+ * k1.parse("Hobitti1 |J.R.R. Tolkien||336");
+ * k2.parseTiedostosta("2|Hobitti2 |J.R.R. Tolkien||336");
+ * k3.parseTiedostosta("3|Hobitti3 |J.R.R. Tolkien||336");
+ * 
+ * 
+ * 
+ * kirjat.lisaa(k1);
+ * kirjat.lisaa(k2);
+ * kirjat.lisaa(k3);
+ * 
+ * 
+ * kirjat.hae(k1.getId()).getNimi() === "Hobitti1";
+ * kirjat.hae(k3.getId()).getNimi() === "Hobitti3";
+ * kirjat.hae(1); #THROWS NoSuchElementException
+ * kirjat.hae(5); #THROWS NoSuchElementException
+ * 
+ * int k2Id = k2.getId();
+ * kirjat.poista(k2Id);
+ * kirjat.poista(1); #THROWS NoSuchElementException
+ * kirjat.hae(k2Id); #THROWS NoSuchElementException
+ * 
+ * </pre>
+ */
+public class Kirjat {
+    private int maxLkm = 8;
+    private int lkm = 0;
+    private Kirja[] alkiot = new Kirja[maxLkm];
+    private static boolean muutettu = false;
+    
+    
+    /**
+     * @param kirja Lisättävä kirja
+     * <pre name="test">
+     * Kirja kirja = new Kirja();
+     * Kirjat kirjat = new Kirjat();
+     * for (int i = 0; i < 8; i++) {
+     *     kirjat.lisaa(kirja);
+     *     kirjat.getLkm() === i + 1;
+     * }
+     * kirjat.getLkm() === 8;
+	 * 
+	 * 
+	 * </pre>
+     */
+    public void lisaa(Kirja kirja) {
+        if (this.lkm >= this.alkiot.length) {
+            Kirja[] uusi = new Kirja[this.lkm * 2];
+            for (int i = 0; i < this.lkm; i++) {
+                uusi[i] = this.alkiot[i];
+            }
+            this.alkiot = uusi;
+        }
+        this.alkiot[this.lkm] = kirja;
+        this.lkm++;
+        muutettu = true;
+    }
+    
+    
+    /**
+     * Poistaa kirjan annetulla id:llä
+     * @param id Poistettavan kirjan id
+     * @throws NoSuchElementException Jos id:tä vastaavaa kirjaa ei löydy
+     */
+    public void poista(int id) throws NoSuchElementException {
+        int luku, kirj;
+        for (luku = 0, kirj = 0; luku < this.lkm; luku++) {
+            if (this.alkiot[luku].getId() != id)  {
+                this.alkiot[kirj++] = this.alkiot[luku];
+            }
+        }
+        this.lkm = kirj;
+        
+        // Asettaa taulukon lukualueen ulkopuolelle jäävät viitteet nolliksi,
+        // jottei tule turhaa roskaa
+        for (int i = kirj; i < alkiot.length; i++) {
+            alkiot[i] = null;
+        }
+        
+        muutettu = true;
+        if (luku == kirj) throw new NoSuchElementException("Kirjaa id:llä " + id + " ei löydy.");
+    }
+
+    /**
+     * Hakee kirjan id:n perusteella
+     * @param id Halutun kirjan id
+     * @return Viite kirjaan halutulla id:llä
+     * @throws NoSuchElementException Jos Id:tä vastaavaa kirjaa ei löydy
+     */
+    public Kirja hae(int id) throws NoSuchElementException {
+        
+        for (int i = 0; i < this.lkm; i++) {
+            if (alkiot[i].getId() == id) return alkiot[i];
+        }
+        
+        throw new NoSuchElementException("Kirjaa id:llä " + id + " ei löytynyt.");
+    }
+
+    
+    /**
+     * Hakee kirjan indeksin perusteella
+     * @param ind Indeksipaikka, josta kirja haetaan
+     * @return Kirja annetussa indeksipaikassa
+     */
+    public Kirja haeIndeksilla(int ind) {
+        if (ind < 0 || ind >= this.lkm) throw new NullPointerException("Laiton indeksi");
+        return alkiot[ind];
+    }
+    
+    
+    /**
+     * Palauttaa kirjojen lukumäärän
+     * @return kirjojen lukumäärä
+     */
+    public int getLkm() {
+        return this.lkm;
+    }
+
+
+    /**
+     * Lukee tiedostosta kirjojen tiedot ja lisää ne taulukkoon
+     */
+    public void lueTiedosto() {
+        
+        try (Scanner fi = new Scanner(new File("tiedostot\\kirjat.dat"))) {
+            while (fi.hasNextLine()) {
+                String rivi = fi.nextLine();
+                Kirja kirja = new Kirja();
+                kirja.parseTiedostosta(rivi);
+                this.lisaa(kirja);
+            }
+            muutettu = false;
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        } 
+        
+    }
+
+
+    /**
+     * Kirjoittaa kirjojen tiedot tiedostoon
+     */
+    public void tallenna() {
+        
+        if (!muutettu) return;
+        
+        try (PrintStream fo = new PrintStream(new File("tiedostot\\kirjat.dat"))) {
+            
+            for (int i = 0; i < this.lkm; i++) {
+                fo.println(alkiot[i]);
+            }
+            
+        } catch (FileNotFoundException e) {
+            System.err.println(e.getMessage());
+        }
+        
+    }
+
+}

src/Kirjalista/SailoException.java

+package Kirjalista;
+
+/**
+ * Poikkeusluokka tietorakenteesta aiheutuville poikkeuksille.
+ * @author Vesa Lappalainen
+ * @version 1.0, 22.02.2003
+ */
+public class SailoException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+
+    /**
+     * Poikkeuksen muodostaja jolle tuodaan poikkeuksessa
+     * käytettävä viesti
+     * @param viesti Poikkeuksen viesti
+     */
+    public SailoException(String viesti) {
+        super(viesti);
+    }
+}

src/Kirjalista/test/GenreRelaatioTest.java

+package Kirjalista.test;
+// Generated by ComTest BEGIN
+import java.util.ArrayList;
+import static org.junit.Assert.*;
+import org.junit.*;
+import Kirjalista.*;
+// Generated by ComTest END
+
+/**
+ * Test class made by ComTest
+ * @version 2025.04.01 16:53:55 // Generated by ComTest
+ *
+ */
+@SuppressWarnings({ "all" })
+public class GenreRelaatioTest {
+
+
+
+  // Generated by ComTest BEGIN
+  /** testHaeKirjat38 */
+  @Test
+  public void testHaeKirjat38() {    // GenreRelaatio: 38
+    GenreRelaatio gr = new GenreRelaatio(); 
+    Kirja k = Kirja.testiKirja(); 
+    Kirja k1 = Kirja.testiKirja(); 
+    Kirja k2 = Kirja.testiKirja(); 
+    Genre g = Genre.testiGenre(); 
+    Genre g2 = Genre.testiGenre(); 
+    gr.lisaa(new KirjanGenre(k, g)); 
+    gr.lisaa(new KirjanGenre(k1, g)); 
+    gr.lisaa(new KirjanGenre(k2, g)); 
+    gr.lisaa(new KirjanGenre(k, g2)); 
+    ArrayList<Integer> al = gr.haeKirjat(g.getId()); 
+    int i = al.get(0); 
+    int i1 = al.get(1); 
+    int i2 = al.get(2); 
+    assertEquals("From: GenreRelaatio line: 55", k.getId(), i); 
+    assertEquals("From: GenreRelaatio line: 56", k1.getId(), i1); 
+    assertEquals("From: GenreRelaatio line: 57", k2.getId(), i2); 
+    assertEquals("From: GenreRelaatio line: 58", 3, al.size()); 
+  } // Generated by ComTest END
+
+
+  // Generated by ComTest BEGIN
+  /** testHaeGenret85 */
+  @Test
+  public void testHaeGenret85() {    // GenreRelaatio: 85
+    GenreRelaatio gr = new GenreRelaatio(); 
+    Kirja k = Kirja.testiKirja(); 
+    Kirja k2 = Kirja.testiKirja(); 
+    Genre g = Genre.testiGenre(); 
+    Genre g1 = Genre.testiGenre(); 
+    Genre g2 = Genre.testiGenre(); 
+    gr.lisaa(new KirjanGenre(k, g2)); 
+    gr.lisaa(new KirjanGenre(k, g)); 
+    gr.lisaa(new KirjanGenre(k, g1)); 
+    gr.lisaa(new KirjanGenre(k2, g)); 
+    ArrayList<Integer> al = gr.haeGenret(k.getId()); 
+    int i = al.get(0); 
+    int i1 = al.get(1); 
+    int i2 = al.get(2); 
+    assertEquals("From: GenreRelaatio line: 101", g2.getId(), i); 
+    assertEquals("From: GenreRelaatio line: 102", g.getId(), i1); 
+    assertEquals("From: GenreRelaatio line: 103", g1.getId(), i2); 
+    assertEquals("From: GenreRelaatio line: 105", 3, al.size()); 
+  } // Generated by ComTest END
+
+
+  // Generated by ComTest BEGIN
+  /** testPoista129 */
+  @Test
+  public void testPoista129() {    // GenreRelaatio: 129
+    GenreRelaatio gr = new GenreRelaatio(); 
+    Kirja k = Kirja.testiKirja(); 
+    Kirja k1 = Kirja.testiKirja(); 
+    Kirja k2 = Kirja.testiKirja(); 
+    Genre g = Genre.testiGenre(); 
+    gr.lisaa(new KirjanGenre(k, g)); 
+    gr.lisaa(new KirjanGenre(k1, g)); 
+    gr.lisaa(new KirjanGenre(k2, g)); 
+    gr.lisaa(new KirjanGenre(k, g)); 
+    int i1 = gr.haeKirjat(g.getId()).get(0); 
+    assertEquals("From: GenreRelaatio line: 142", k.getId(), i1); 
+    gr.poista(k.getId()); 
+    i1 = gr.haeKirjat(g.getId()).get(0); 
+    assertEquals("From: GenreRelaatio line: 145", k1.getId(), i1); 
+  } // Generated by ComTest END
+}
\ No newline at end of file