Oppgavesett 1

Fra Hiofwiki

Oppgavesett

Løsningsforslag (Gruppe 1 og 2)

Innhold 1 Løsningsforslag (Gruppe 1 og 2) 1.1 Oppgave 1 1.2 Oppg 2 1.3 Oppg 3 1.4 Oppg 4

Oppgave 1

• Bruk klassen ArrayList til å lage to lister med objekter av en klasse du selv velger:

       // Lager her to lister med navn siden de skal flettes og sorteres i ettertid
       ArrayList<String> navn = new ArrayList<String>();
       
       navn.add("Kåre");
       navn.add("Nils");
       navn.add("Arne");
       navn.add("Johan");
       
       ArrayList<String> flereNavn = new ArrayList<String>();
       
       flereNavn.add("Nils");
       flereNavn.add("Bjarne");
       flereNavn.add("Byggmester Bob");
       flereNavn.add("Lewis");
       flereNavn.add("Chase");

• Sorter listene:

       // Forutsetningen for at listene skal kunne sorteres er at de implementerer interfacet
       // Comparable, og dermed må implementere metoden compareTo(). Denne metoden bør
       // implementeres slik at den returnerer en verdi < 0 hvis objekt a i a.compareTo(b) skal
       // komme før b, eller verdi > 0 hvis b skal komme før a.
       Collections.sort(navn);
       Collections.sort(flereNavn);

• Finn ut hvilke elementer de to listene har til felles (bruk f.eks. et HashSet):

       // Med HashSet (HashSet's add() metode returnerer false om elementet allerede er i settet)
       HashSet<String> navnSet = new HashSet<String>(n1);

       for (String n2 : navn) {
           if (!navnSet.add(n2))
               System.out.println(n2 + " finnes i begge lister.");
       }

       // Uten HashSet – sparer minne / prosesseringstid da man ikke trenger å lage et
       // HashSet objekt
       System.out.println("\n-----------------\n");
       for (String n1 : navn) {
           for (String n2 : flereNavn) {
               if (n1.equals(n2))
                   System.out.println(n1 + " finnes i begge lister.");
           }
       }

• Lag din egen flette-algoritme som fungerer for sorterte lister. Flett de to listene sammen til en tredje sortert liste:

       // Opprett en ny arrayliste, legg til alle navnene og sorter dem
       ArrayList<String> sammenFlettet = new ArrayList<String>();
       sammenFlettet.addAll(navn);
       sammenFlettet.addAll(flereNavn);
       Collections.sort(sammenFlettet);

• Finn duplikater i den flettede listen og fjern dem:

       // HashSet legger ikke til duplikater fra Collection man spesifiserer som parameter
       HashSet<String> navnUtenDuplikater = new HashSet<String>(sammenFlettet);
       for (String n : navnUtenDuplikater)
           System.out.println(n);
       
       // Alternativt, overskriv den gamle arraylisten med hashsettet
       // uten duplikater og sorter den:
       sammenFlettet = new ArrayList<String>(navnUtenDuplikater);
       Collections.sort(sammenFlettet);

Oppg 2

• Lag en metode som tar som parametere to lister med objekter, og som returnerer en sortert liste hvor eventuelle duplikater er fjernet. Lag metoden generisk, slik at den kan brukes på alle objekter som er sammenliknbare med seg selv.

Bruker her generics slik at man kan sende inn en ArrayList med hvilken-som-helst type som implementerer interfacet Comparable, som trengs for sammenlikning (f.eks sortering)

   // Flettealgoritme (med HashSet):
   // 1. Legg sammen alle navn i et HashSet (fjerner automatisk duplikater)
   // 2. Sorter
   static <T extends Comparable<? super T>> ArrayList<T> flettSammen2(ArrayList<T> liste1, ArrayList <T> liste2)
   {
       HashSet<T> flettSet = new HashSet<T>();
       
       // Legg til alle elementene i begge listene (ikke duplikater) til hashset-et
       flettSet.addAll(liste1);
       flettSet.addAll(liste2);
       
       // Lag en arraylist av hashsettet, sorter og returner den
       ArrayList<T> returnListe = new ArrayList<T>(flettSet);
       Collections.sort(returnListe);
       
       return returnListe;
   }

Oppg 3

• Lag et program som leser inn en setning, og som skriver ut en rapport som viser hvor mange forekomster det er av hvert ord i setningen. Bruk for eksempel en HashMap til opptellingen:

       // Wrapper System.in i en BufferedReader slik at man kan bruke ReadLine()
       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
       String input = "";
       
       // Les inn linje fra bruker
       System.out.println("Skriv inn en setning og trykk enter:\n");
       try {
           input = reader.readLine();
       } catch (IOException ioe) {
           System.out.println(ioe);
       }
       
       // Generer et hashmap av ordene som ble brukt og antall forekomster av dem
       HashMap<String, Integer> forekomster = LagRapport(input);
       
       // Print ut hashmappet
       for (String ord : forekomster.keySet())
           System.out.println(forekomster.get(ord) + " forekomster av ordet " + ord);

Metode som genererer HashMap:

   // LagRapport finner antall forekomster av ord og legger resultatet
   // i en HashMap, der nøkkelen er ordet og verdien er antall forekomster.
   // 1. Lagre alle ordene i et streng-array
   // 2. Finn ut om ordet allerede eksisterer i Hash mappet
   //    - Hvis ja: Legg til antall forekomster til variabelen antall
   // 3. Legg til ordet (på nytt) med bestemt antall
   static HashMap<String, Integer> LagRapport(String input) {
       HashMap<String, Integer> ord = new HashMap<String, Integer>();
       String[] ordArray = input.split(" ");
       
       for (int i = 0; i < ordArray.length; i++) {
           int antall = 1;
           
           if (ord.containsKey(ordArray[i]))
               antall += (int) ord.get(ordArray[i]);
           
           ord.put(ordArray[i], Integer.valueOf(antall));
       }
       
       return ord;
   }

Oppg 4

• Last ned ett av datasettene cities1000 eller cities15000 fra http://www.geonames.org . Ta utgangspunkt i programmene fra forelesningen eller lag din egne.

Bruker Mari-Ann's By / ByLeser klasser for denne oppgaven.

• Gjør en opptelling av antall byer som er registrert for hvert land, og skriv ut en oversikt:

       // Liste for å holde byene
       ArrayList<By> byer = new ArrayList<By>();
       
       // Opprett et leser objekt og les inn byene inn i listen
       ByLeser byLeser = new ByLeser("cities1000.txt");
       byLeser.les(byer);
       
       // Skriv ut antall byer
       System.out.println("Antall byer: " + byer.size());
       
       // Skriv ut oversikt
       for (By b : byer)
           System.out.println(b);

• Hvordan vil du organisere datamaterialet hvis det skal være enkelt å hente ut alle byer som er registrert for et land, sortert etter innbyggertall?

Man lager en liste med byer som over, så kan man lage en komparator med formål å sortere etter innbyggertall:

public class InnbyggerComparator implements Comparator<By> {
   // Vil sortere i avtagende rekkefølge – hvis innbyggertallene er like, vil den bruke
   // By's compareTo metode (som vil sortere alfabetisk)
   public int compare(By b1, By b2) {
       int diff = b2.hentInnbyggertall() - b1.hentInnbyggertall();
       return (diff != 0) ? diff : b1.compareTo(b2);
   }
}

Deretter bruker man denne komparatoren som parameter til Collections.sort();

       Collections.sort(byer, new InnbyggerComparator());

• Samme som over, men sortert etter lengde- eller breddegrad, slik at man kan få ut oversikter over alle byer registrert for et land, sortert fra sør til nord eller øst til vest:

Lager to nye komparatorer for lengde/breddegrad (begge sorteres i avtakende rekkefølge). Trenger bare bytte ut hentInnbyggertall() med hentLengdeGrad() og hentBreddeGrad():

public class LengdegradComparator implements Comparator<By> {
   public int compare(By b1, By b2) {
       int diff = (int)(b2.hentLengdegrad() - b1.hentLengdegrad());
       return (diff != 0) ? diff : b1.compareTo(b2);
   }
}

public class BreddegradComparator implements Comparator<By> {
   public int compare(By b1, By b2) {
       int diff = (int)(b2.hentBreddegrad() - b1.hentBreddegrad());
       return (diff != 0) ? diff : b1.compareTo(b2);
   }
}