Commit b1a7287f authored by Anya Helene Bagge's avatar Anya Helene Bagge 🦆

stuff fra eksamensgjennomgang

parent cfd3c746
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
<classpathentry kind="output" path="bin"/>
</classpath>
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>inf101.v16.eks.h15</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.8
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.source=1.8
import java.util.Iterator;
public interface ICollection<E> extends Iterable<E> {
/**
* Add an element to the collection
*
*
* @param elt
* The element
*/
void add(E elt);
/**
* Check if the collection contains the given element
*
* @param elt
* The element
* @return True if the element is in the collection
*/
boolean contains(E elt);
/**
* @return True if the collection is empty
*/
boolean isEmpty();
// From Iterable<E>: returns an iterator
@Override
Iterator<E> iterator();
/**
* Remove an element from the collection
*
* @return The element removed
* @throws IndexOutOfBoundsException
* if the collection is empty
*/
E remove();
/**
* Remove an element from the collection
*
* Will find and remove an element which is equals() to the provided
* element, if any.
*
* @param elt
* The element to remove
* @return The element removed, or null if not found
*/
E remove(E elt);
/**
* @return The number of elements in the collection
*/
int size();
}
public interface ISet<E> extends ICollection<E>{
/**
* Remove an element from the collection
*
* Will find and remove an element which is equals() to the provided
* element, if any.
*
* Afterwards, contains(elt) will be false.
*
* @param elt
* The element to remove
* @return The element removed, or null if not found
*/
E remove(E elt);
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Implementation of an unordered collection of elements.
*
* @author Anya Helene Bagge
*
* @param <E> The element type
*/
public class MyCollection<E> implements ICollection<E> {
protected final List<E> list = new ArrayList<>();
@Override
public void add(E elt) {
list.add(elt);
}
@Override
public boolean contains(E elt) {
return list.contains(elt);
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public Iterator<E> iterator() {
return list.iterator();
}
@Override
public E remove() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("List is empty");
}
return list.remove(0);
}
@Override
public E remove(E elt) {
int r = list.indexOf(elt);
if (r >= 0)
return list.remove(r);
else
return null;
}
@Override
public int size() {
return list.size();
}
public static void checkState() {
// always OK, since list can never be null, and there are
// nothing in particluar is required of its element
}
}
import java.util.Iterator;
public class MySet<E> extends MyCollection<E> implements ISet<E> {
public boolean equals(Object other) {
if(this == other)
return true;
if(other instanceof ISet<?>) {
ISet<E> otherSet = (ISet<E>) other;
int sizeThis = size();
int sizeOther = ((ISet) other).size();
if(sizeThis != sizeOther)
return false;
// ISet<E> copy = new MySet<>(this);
// SetOperations.union(copy, (ISet<E>)otherSet);
//
// return copy.size() == sizeThis;
for(E e : this) {
if(!otherSet.contains(e))
return false;
}
return true;
}
}
@Override
public void add(E elt) {
if(!contains(elt))
super.add(elt);
}
}
import java.util.Iterator;
public class SetOperations {
private SetOperations() {
}
public static <E> void union(ISet<E> a, ISet<E> b) {
for(E e : b)
a.add(e);
}
public static <E> void isect(ISet<E> a, ISet<E> b) {
// går kanskje ikke bra pga ConcurrentModificationException
for(E e : a) {
if(!b.contains(e))
a.remove(e);
}
// mulig løsning: lag en kopi av a, og iterer over den
// bruk iteratorens remove metode
Iterator<E> iterator = a.iterator();
while(iterator.hasNext()) {
E e = iterator.next();
if(!b.contains(e))
iterator.remove();
}
}
public static <E> void diff(ISet<E> a, ISet<E> b) {
for(E e : b) {
a.remove(e);
}
}
}
import org.junit.Test;
//import org.junit.assertions.*;
public class SetTest {
// sjekker at elementet er med i settet etter at det er lagt til
public <E >void addContainsProperty(ISet<E> set, E elt) {
set.add(elt);
assertTrue(set.contains(elt));
}
// sjekker at elementet ikke er med i settet etter at det er fjernet
public <E >void removeContainsProperty(ISet<E> set, E elt) {
set.remove(elt);
assertFalse(set.contains(elt));
}
public <E >void addAddSizeProperty(ISet<E> set, E elt) {
set.add(elt);
int gammelStørrelse = set.size();
set.add(elt);
assertEquals(gammelStørrelse, set.size());
}
public <E >void addAddRemoveContainsProperty(ISet<E> set, E elt) {
set.add(elt);
set.add(elt);
set.remove(elt);
assertFalse(set.contains(elt));
}
public <E> void unionContains(ISet<E> set1, ISet<E> set2, E elt) {
if(set1.contains(elt) || set2.contains(elt)) {
SetOperations.union(set1, set2);
assertTrue(set1.contains(elt));
}
// bedre måte:
boolean isIn1 = set1.contains(elt);
boolean isIn2 = set2.contains(elt);
SetOperations.union(set1, set2);
assertEquals(isIn1 || isIn2, set1.contains(elt));
}
public <E> void unionContains(ISet<E> set1, ISet<E> set2, E elt) {
boolean isIn1 = set1.contains(elt);
boolean isIn2 = set2.contains(elt);
SetOperations.isect(set1, set2);
assertEquals(isIn1 && isIn2, set1.contains(elt));
}
public static final int N = 10000;
@Test
public void addContainsTest() {
for(int i = 0; i < N; i++) {
addContainsProperty(setGen.generate(), elemGen.generate());
}
}
public boolean setEquals(ISet<E>
}
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
<classpathentry kind="output" path="bin"/>
</classpath>
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>inf101v16f21</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.8
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.source=1.8
package inf101.immutable;
public class ImmutableNavn {
final String fornavn;
final String etternavn;
public ImmutableNavn(String fornavn, String etternavn) {
super();
this.fornavn = fornavn;
this.etternavn = etternavn;
}
public String getFornavn() {
return fornavn;
}
public String getEtternavn() {
return etternavn;
}
@Override
public String toString() {
return "ImmutableNavn [fornavn=" + fornavn + ", etternavn=" + etternavn + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((etternavn == null) ? 0 : etternavn.hashCode());
result = prime * result + ((fornavn == null) ? 0 : fornavn.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ImmutableNavn other = (ImmutableNavn) obj;
if (etternavn == null) {
if (other.etternavn != null)
return false;
} else if (!etternavn.equals(other.etternavn))
return false;
if (fornavn == null) {
if (other.fornavn != null)
return false;
} else if (!fornavn.equals(other.fornavn))
return false;
return true;
}
public ImmutableNavn setFornavn(String fn) {
return new ImmutableNavn(fn, etternavn);
}
}
package inf101.immutable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) {
ImmutableNavn n = new ImmutableNavn("Per", "Hansen");
Person per1 = new Person(n);
Person per2 = new Person(n);
per1.setSjef(per2);
System.out.println("Sjefen heter: " + per1.getSjef().getNavn());
System.out.println("Undersåtten heter: " + per1.getNavn());
per1.setNavn(per1.getNavn().setFornavn("Ole")); //getNavn().setEtternavn("Hansen-Persson");
System.out.println("Sjefen heter: " + per1.getSjef().getNavn());
System.out.println("Undersåtten heter: " + per1.getNavn());
Map<Person, Integer> lønn = new HashMap<>();
lønn.put(per1, 5000);
per1.setNavn(per1.getNavn().setFornavn("Clark")); //getNavn().setEtternavn("Hansen-Persson");
lønn.put(per2, 10000);
System.out.println("Sjefen tjener: " + lønn.get(per2));
System.out.println("Undersåtten tjener: " + lønn.get(per1));
System.out.println();
System.out.println();
System.out.println();
System.out.println();
System.out.println();
List<Person> ansattListe = new ArrayList<>();
ansattListe.add(new Person("Clark", "Kent"));
ansattListe.add(new Person("Bruce", "Banner"));
ansattListe.add(new Person("Petter", "Bjørstad"));
Sjef sjef = new Sjef(new ImmutableNavn("Ånya", "Bågge"), ansattListe);
// mulig problem: kan vi endre ansattlisten etter at sjefen
// har fått den?
// sjef.setAnsatte(ansattListe);
ansattListe = sjef.getAnsatte();
// vi har fremdeles tilgang på Person-objektet å kan endre på det
ansattListe.get(0).setNavn(new ImmutableNavn("A", "B"));
// har vi fremdeles tilgang på ansattlisten til sjefen, slik at vi kan endre den?
try {
ansattListe.add(new Person("Petter", "Bjærstad"));
ansattListe.add(new Person("Petter", "Bjårstad"));
ansattListe.add(new Person("Petter", "Bjurstad"));
ansattListe.add(new Person("Petter", "Bjyrstad"));
}
catch(UnsupportedOperationException e) {
System.out.println("Sjefens ansattliste er skrivebeskyttet!");
}
System.out.println("De ansatte er: ");
// sjef.ansatte.add(new Person("A", "b"));
// sjef.ansatte.add(new Person("A", "b"));
// sjef.ansatte.add(new Person("A", "b"));
// sjef.ansatte.add(new Person("A", "b"));
// sjef.ansatte.add(new Person("A", "b"));
// sjef.ansatte.add(new Person("A", "b"));
for(Person p : sjef.getAnsatte()) {
System.out.println("Ansatt: " + p.getNavn());
}
}
}
package inf101.immutable;
public class Navn {
String fornavn;
String etternavn;
@Override
public String toString() {
return fornavn + " " + etternavn;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((etternavn == null) ? 0 : etternavn.hashCode());
result = prime * result + ((fornavn == null) ? 0 : fornavn.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Navn other = (Navn) obj;
if (etternavn == null) {
if (other.etternavn != null)
return false;
} else if (!etternavn.equals(other.etternavn))
return false;
if (fornavn == null) {
if (other.fornavn != null)
return false;
} else if (!fornavn.equals(other.fornavn))
return false;
return true;
}
public String getFornavn() {
return fornavn;
}
public void setFornavn(String fornavn) {
this.fornavn = fornavn;
}
public String getEtternavn() {
return etternavn;
}
public void setEtternavn(String etternavn) {
this.etternavn = etternavn;
}
public Navn(String fornavn, String etternavn) {
super();
this.fornavn = fornavn;
this.etternavn = etternavn;
}
}
package inf101.immutable;
public class Person {
Person sjef;
ImmutableNavn navn;
public Person(String fornavn, String etternavn) {
super();
this.navn = new ImmutableNavn(fornavn, etternavn);
}
public Person(ImmutableNavn navn) {
super();
this.navn = navn;
}
public Person getSjef() {
return sjef;
}
public void setSjef(Person sjef) {
this.sjef = sjef;
}
public ImmutableNavn getNavn() {
return navn;
}
public void setNavn(ImmutableNavn navn) {
this.navn = navn;
}
@Override
public String toString() {
return "Person [navn=" + navn + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((navn == null) ? 0 : navn.hashCode());
result = prime * result + ((sjef == null) ? 0 : sjef.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (navn == null) {
if (other.navn != null)
return false;
} else if (!navn.equals(other.navn))
return false;
if (sjef == null) {
if (other.sjef != null)
return false;
} else if (!sjef.equals(other.sjef))
return false;
return true;
}
}
package inf101.immutable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class Sjef extends Person implements Iterable<Person> {
// hvis ikke private, kan vi umulig garantere at Sjef-objektet
// er konsistent, med f.eks. med <= 5 ansatte og at sjefen ikke er sin egen ansatt
private final List<Person> ansatte;
public Sjef(ImmutableNavn navn, List<Person> ansatte) {
super(navn);
if(ansatte.size() > 5)
throw new IllegalArgumentException("Sjefen kan ikke ha flere ansatte!");
if(ansatte.contains(this))
throw new IllegalArgumentException("Sjefen kan ikke være sin egen sjef!");
this.ansatte = new ArrayList<>(ansatte);
}
public List<Person> getAnsatte() {
// returner en kopi av listen – helt trygt!
// return new ArrayList<>(ansatte);
// returner en referanse til listen som er slik at du
// ikke kan endre på listen
return Collections.unmodifiableList(ansatte);
}
/*
* Dårlig ide å ha setAnsatte – vi kan heller endre ansattlisten
* med addAnsatt, removeAnsatt
*
public void setAnsatte(List<Person> ansatte) {
if(ansatte.size() > 5)
throw new IllegalArgumentException("Sjefen kan ikke ha flere ansatte!");
this.ansatte = new ArrayList<>(ansatte);
}
*/
/* Bedre enn setAnsatte() hvis vi vil gjøre det mulig å legge til mange ansatte i en omgang */
public void addAnsatte(Collection<Person> ans) {
for(Person p : ans)
addAnsatt(p);
}
public void addAnsatt(Person ansatt) {
if(ansatte.size() >= 5)
throw new IllegalStateException("Sjefen kan ikke ha flere ansatte!");
if(ansatt == this)
throw new IllegalArgumentException("Kan ikke være sin egen sjef!");
ansatte.add(ansatt);
}
public void removeAnsatt(Person ansatt) {
ansatte.remove(ansatt);
}
@Override
public Iterator<Person> iterator() {
return Collections.unmodifiableList(ansatte).iterator();
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment