From b2eb22a6cc73048725015d22dba6a23820ef915b Mon Sep 17 00:00:00 2001 From: Peet Date: Thu, 12 Jun 2025 12:10:00 +0200 Subject: [PATCH] uebung09 small adjustments --- uebung09/src/chess/Board.java | 5 +- uebung09/src/collection/BigSet.java | 112 +++++++++++++--------- uebung09/src/collection/EmptySet.java | 65 ++++++++----- uebung09/src/collection/SetDemo.java | 29 ++++++ uebung09/src/collection/SetFactory.java | 7 +- uebung09/src/collection/SingeltonSet.java | 104 +++++++++++--------- uebung09/src/iterator/IteratorDemo.java | 97 +++++++++++++++++++ 7 files changed, 300 insertions(+), 119 deletions(-) create mode 100644 uebung09/src/collection/SetDemo.java create mode 100644 uebung09/src/iterator/IteratorDemo.java diff --git a/uebung09/src/chess/Board.java b/uebung09/src/chess/Board.java index be39951..aa0a9aa 100644 --- a/uebung09/src/chess/Board.java +++ b/uebung09/src/chess/Board.java @@ -1,10 +1,9 @@ package chess; -import java.util.ArrayList; import java.util.Iterator; -import java.util.List; import iterator.Array2dIterator; +import iterator.SkipNullIterator; public class Board implements Iterable { private final Piece[][] field = new Piece[8][8]; @@ -66,6 +65,6 @@ public class Board implements Iterable { @Override public Iterator iterator() { - return new Array2dIterator<>(field); + return new SkipNullIterator<>(new Array2dIterator<>(field)); } } diff --git a/uebung09/src/collection/BigSet.java b/uebung09/src/collection/BigSet.java index db36a69..9a76798 100644 --- a/uebung09/src/collection/BigSet.java +++ b/uebung09/src/collection/BigSet.java @@ -1,21 +1,64 @@ package collection; import java.util.Iterator; +import java.util.Objects; class BigSet implements Set { + private final E first; + private final Set rest; + private final int size; - private E first; - private Set rest; + BigSet(E first, Set rest) { + this.first = Objects.requireNonNull(first); + this.rest = Objects.requireNonNull(rest); + size = 1 + rest.size(); + } - public BigSet(E first, Set rest) { - this.first = first; - this.rest = rest; + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return false; + } + + @Override + public boolean contains(Object el) { + return first.equals(el) || rest.contains(el); + } + + @Override + public boolean subsetOf(Set other) { + return other.contains(first) && rest.subsetOf(other); + } + + @Override + public Set union(Set other) { + return rest.union(other).add(first); + } + + @Override + public Set add(E element) { + if (contains(element)) + return this; + return new BigSet<>(element, this); + } + + @Override + public Set intersection(Set other) { + final Set set = rest.intersection(other); + if (!other.contains(first)) + return set; + else if (set.isEmpty()) + return SetFactory.create(first); + return new BigSet<>(first, set); } @Override public Iterator iterator() { - return new Iterator() { - + return new Iterator<>() { private int cnt; private Iterator restIt; @@ -33,48 +76,31 @@ class BigSet implements Set { return restIt.next(); } }; - } @Override - public int size() { - return rest.size() + 1; + public String toString() { + final StringBuilder b = new StringBuilder("{"); + final Iterator it = iterator(); + while (it.hasNext()) { + b.append(it.next()); + if (it.hasNext()) b.append(", "); + } + b.append('}'); + return b.toString(); } @Override - public boolean isEmpty() { + public int hashCode() { + return 31 * rest.hashCode() + first.hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Set) { + final Set other = (Set) obj; + return this.size() == other.size() && this.subsetOf(other); + } return false; } - - @Override - public boolean contains(Object el) { - return first.equals(el) || rest.contains(el); - } - - @Override - public Set union(Set other) { - return rest.union(other).add(first); - } - - @Override - public Set add(E element) { - if (contains(element)) return this; - return new BigSet(element, this); - } - - @Override - public Set intersection(Set other) { - final Set set = rest.intersection(other); - if (!other.contains(first)) - return set; - else if (set.isEmpty()) - return SetFactory.create(first); - return new BigSet<>(first, set); - - } - - @Override - public boolean subsetOf(Set other) { - return other.contains(first) && rest.subsetOf(other); - } } diff --git a/uebung09/src/collection/EmptySet.java b/uebung09/src/collection/EmptySet.java index a643c2b..a8cc86d 100644 --- a/uebung09/src/collection/EmptySet.java +++ b/uebung09/src/collection/EmptySet.java @@ -5,28 +5,11 @@ import java.util.NoSuchElementException; class EmptySet implements Set { - @Override - public Iterator iterator() { - return new Iterator() { - - @Override - public boolean hasNext() { - return false; - } - - @Override - public E next() { - throw new NoSuchElementException(); - } - - }; - } - @Override public int size() { return 0; } - + @Override public boolean isEmpty() { return true; @@ -38,24 +21,56 @@ class EmptySet implements Set { } @Override - public Set union(Set other) { + public boolean subsetOf(Set other) { + return true; + } + + @Override + public Set union(Set other) { return other; } @Override - public Set add(Object element) { + public Set add(E element) { return SetFactory.create(element); } @Override - public Set intersection(Set other) { - return new EmptySet(); - //return this; + public Set intersection(Set other) { + return this; } @Override - public boolean subsetOf(Set other) { - return true; + public Iterator iterator() { + return new Iterator<>() { + @Override + public boolean hasNext() { + return false; + } + + @Override + public E next() { + throw new NoSuchElementException(); + } + }; } + @Override + public String toString() { + return "{}"; + } + + @Override + public int hashCode() { + return 31; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Set) { + @SuppressWarnings("unchecked") final Set other = (Set) obj; + return other.isEmpty(); + } + return false; + } } diff --git a/uebung09/src/collection/SetDemo.java b/uebung09/src/collection/SetDemo.java new file mode 100644 index 0000000..c9f4d5f --- /dev/null +++ b/uebung09/src/collection/SetDemo.java @@ -0,0 +1,29 @@ +package collection; + +public class SetDemo { + public static void main(String[] args) { + final Set set1 = SetFactory.create(); + System.out.println("set1 = " + set1); + + final Set set2 = set1.add("foo"); + System.out.println("set2 = " + set2); + + final Set set3 = set2.add("foo"); + System.out.println("set3 = " + set3); + + final Set set4 = set3.add("bar"); + System.out.println("set4 = " + set4); + + final Set set5 = SetFactory.create("foo", "baz", "foo"); + System.out.println("set5 = " + set5); + + final Set set6 = set4.union(set5); + System.out.println("set6 = " + set6); + + final Set set7 = set4.intersection(set5); + System.out.println("set7 = " + set7); + + final Set set8 = set5.intersection(set4); + System.out.println("set8 = " + set8); + } +} diff --git a/uebung09/src/collection/SetFactory.java b/uebung09/src/collection/SetFactory.java index 7bf5528..0d8a9d1 100644 --- a/uebung09/src/collection/SetFactory.java +++ b/uebung09/src/collection/SetFactory.java @@ -2,6 +2,9 @@ package collection; public class SetFactory { + // Notwendig um einen korrekten Vergleich von EmptySet zu ermöglichen + private static final EmptySet EMPTY_SET = new EmptySet<>(); + private SetFactory() { /* don't instantiate */ } /** @@ -11,7 +14,7 @@ public class SetFactory { * @return the empty set. */ static Set create() { - return new EmptySet(); + return (Set) EMPTY_SET; } /** @@ -22,7 +25,7 @@ public class SetFactory { * @return the singleton set containing the specified element. */ static Set create(T element) { - return new SingeltonSet(element); + return new SingeltonSet<>(element); } /** diff --git a/uebung09/src/collection/SingeltonSet.java b/uebung09/src/collection/SingeltonSet.java index 75ce75d..fc555a0 100644 --- a/uebung09/src/collection/SingeltonSet.java +++ b/uebung09/src/collection/SingeltonSet.java @@ -2,37 +2,13 @@ package collection; import java.util.Iterator; import java.util.NoSuchElementException; +import java.util.Objects; class SingeltonSet implements Set { + private final E element; - private final E elem; - - public SingeltonSet(E elem) { - this.elem = elem; - } - - @Override - public Iterator iterator() { - return new Iterator() { - - boolean returned = true; - - @Override - public boolean hasNext() { - return returned; - } - - @Override - public E next() { - if(!hasNext()) { - throw new NoSuchElementException(); - } - - returned = false; - return elem; - } - - }; + SingeltonSet(E element) { + this.element = Objects.requireNonNull(element); } @Override @@ -47,31 +23,67 @@ class SingeltonSet implements Set { @Override public boolean contains(Object el) { - return elem.equals(el); + return element.equals(el); } @Override - public Set union(Set other) { - return other.add(elem); + public boolean subsetOf(Set other) { + return other.contains(element); } @Override - public Set add(Object element) { - if (elem.equals(element)) { + public Set union(Set other) { + return other.add(element); + } + + @Override + public Set add(E element) { + if (this.element.equals(element)) return this; + return new BigSet<>(element, this); + } + + @Override + public Set intersection(Set other) { + return other.contains(element) ? this : SetFactory.create(); + } + + @Override + public Iterator iterator() { + return new Iterator<>() { + boolean ready = true; + + @Override + public boolean hasNext() { + return ready; + } + + @Override + public E next() { + if (!ready) + throw new NoSuchElementException(); + ready = false; + return element; + } + }; + } + + @Override + public String toString() { + return "{" + element + "}"; + } + + @Override + public int hashCode() { + return 47 * element.hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Set) { + final Set other = (Set) obj; + return other.size() == 1 && other.contains(element); } - - return new BigSet(element, this); + return false; } - - @Override - public Set intersection(Set other) { - return other.contains(elem) ? this : SetFactory.create(); - } - - @Override - public boolean subsetOf(Set other) { - return other.contains(elem); - } - } diff --git a/uebung09/src/iterator/IteratorDemo.java b/uebung09/src/iterator/IteratorDemo.java new file mode 100644 index 0000000..3846a53 --- /dev/null +++ b/uebung09/src/iterator/IteratorDemo.java @@ -0,0 +1,97 @@ +package iterator; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; + +public class IteratorDemo { + private static void demoArray2dIterator() { + System.out.println("Array2dIterator {{}, {\"foo\", \"bar\"}, {\"baz\"}, {}}"); + final String[][] array = {{}, {"foo", "bar"}, {"baz"}, {}}; + final Iterator it = new Array2dIterator<>(array); + while (it.hasNext()) + System.out.println(it.next()); + } + + private static void demoArray2dIteratorOnlyEmpty() { + System.out.println("Array2dIterator {{}, {}, {}}"); + final String[][] array = {{}, {}, {}}; + final Iterator it = new Array2dIterator<>(array); + while (it.hasNext()) + System.out.println(it.next()); + } + + private static void demoArray2dIteratorEmpty() { + System.out.println("Array2dIterator {}"); + final String[][] array = {}; + final Iterator it = new Array2dIterator<>(array); + while (it.hasNext()) + System.out.println(it.next()); + } + + private static void demoSkipNullIterator() { + System.out.println("SkipNullIterator [\"a\", \"b\", null, \"c\"]"); + final Iterator oriIt = Arrays.asList("a", "b", null, "c").iterator(); + final Iterator it = new SkipNullIterator<>(oriIt); + while (it.hasNext()) + System.out.println(it.next()); + } + + private static void demoSkipNullIteratorSingleton() { + System.out.println("SkipNullIterator [\"foo\"]"); + final Iterator oriIt = List.of("foo").iterator(); + final Iterator it = new SkipNullIterator<>(oriIt); + while (it.hasNext()) + System.out.println(it.next()); + } + + private static void demoSkipNullIteratorInfinity() { + System.out.println("SkipNullIterator [\"infinity\", \"infinity\", ...]"); + final Iterator oriIt = new Iterator<>() { + @Override + public boolean hasNext() { + return true; + } + + @Override + public String next() { + return "infinity"; + } + }; + + final Iterator it = new SkipNullIterator<>(oriIt); + for (int i = 0; i < 10; i++) + System.out.println(i + ": " + it.next()); + } + + private static void demoPathological() { + System.out.println("SkipNullIterator [null, ..., null, \"infinity\", \"infinity\", ...]"); + final Iterator oriIt = new Iterator<>() { + private int ctr; + + @Override + public boolean hasNext() { + return true; + } + + @Override + public String next() { + return ctr++ > 100000 ? "infinity" : null; + } + }; + + final SkipNullIterator it = new SkipNullIterator<>(oriIt); + for (int i = 0; i < 10; i++) + System.out.println(i + ": " + it.next()); + } + + public static void main(String[] args) { + demoArray2dIterator(); + demoArray2dIteratorEmpty(); + demoArray2dIteratorOnlyEmpty(); + demoSkipNullIterator(); + demoSkipNullIteratorSingleton(); + demoSkipNullIteratorInfinity(); + demoPathological(); + } +}