uebung09 small adjustments

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<Piece> {
     private final Piece[][] field = new Piece[8][8];
@@ -66,6 +65,6 @@ public class Board implements Iterable<Piece> {
 
     @Override
     public Iterator<Piece> iterator() {
-        return new Array2dIterator<>(field);
+        return new SkipNullIterator<>(new Array2dIterator<>(field));
     }
 }

uebung09/src/collection/BigSet.java

@@ -1,21 +1,64 @@
 package collection;
 
 import java.util.Iterator;
+import java.util.Objects;
 
 class BigSet<E> implements Set<E> {
+    private final E first;
+    private final Set<E> rest;
+    private final int size;
 
-    private E first;
+    BigSet(E first, Set<E> rest) {
-    private Set<E> rest;
+        this.first = Objects.requireNonNull(first);
+        this.rest = Objects.requireNonNull(rest);
+        size = 1 + rest.size();
+    }
 
-    public BigSet(E first, Set<E> rest) {
+    @Override
-        this.first = first;
+    public int size() {
-        this.rest = rest;
+        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<E> union(Set<E> other) {
+        return rest.union(other).add(first);
+    }
+
+    @Override
+    public Set<E> add(E element) {
+        if (contains(element))
+            return this;
+        return new BigSet<>(element, this);
+    }
+
+    @Override
+    public Set<E> intersection(Set<E> other) {
+        final Set<E> 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<E> iterator() {
-        return new Iterator<E>() {
+        return new Iterator<>() {
-            
             private int cnt;
             private Iterator<E> restIt;
 
@@ -33,48 +76,31 @@ class BigSet<E> implements Set<E> {
                 return restIt.next();
             }
         };
-
     }
 
     @Override
-    public int size() {
+    public String toString() {
-        return rest.size() + 1;
+        final StringBuilder b = new StringBuilder("{");
+        final Iterator<E> 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<E> union(Set<E> other) {
-        return rest.union(other).add(first);
-    }
-
-    @Override
-    public Set<E> add(E element) {
-        if (contains(element)) return this;
-        return new BigSet<E>(element, this);
-    }
-
-    @Override
-    public Set<E> intersection(Set<E> other) {
-        final Set<E> 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);
-    }
 }

uebung09/src/collection/EmptySet.java

@@ -5,23 +5,6 @@ import java.util.NoSuchElementException;
 
 class EmptySet<E> implements Set<E> {
 
-    @Override
-    public Iterator<E> iterator() {
-        return new Iterator<E>() {
-
-            @Override
-            public boolean hasNext() {
-                return false;
-            }
-
-            @Override
-            public E next() {
-                throw new NoSuchElementException();
-            }
-            
-        };
-    }
-
     @Override
     public int size() {
         return 0;
@@ -38,24 +21,56 @@ class EmptySet<E> implements Set<E> {
     }
 
     @Override
-    public Set union(Set other) {
+    public boolean subsetOf(Set<?> other) {
+        return true;
+    }
+
+    @Override
+    public Set<E> union(Set<E> other) {
         return other;
     }
 
     @Override
-    public Set add(Object element) {
+    public Set<E> add(E element) {
         return SetFactory.create(element);
     }
 
     @Override
-    public Set intersection(Set other) {
+    public Set<E> intersection(Set<E> other) {
-        return new EmptySet();
+        return this;
-        //return this;
     }
 
     @Override
-    public boolean subsetOf(Set other) {
+    public Iterator<E> iterator() {
-        return true;
+        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<E> other = (Set<E>) obj;
+            return other.isEmpty();
+        }
+        return false;
+    }
 }

uebung09/src/collection/SetDemo.java

@@ -0,0 +1,29 @@
+package collection;
+
+public class SetDemo {
+    public static void main(String[] args) {
+        final Set<String> set1 = SetFactory.create();
+        System.out.println("set1 = " + set1);
+
+        final Set<String> set2 = set1.add("foo");
+        System.out.println("set2 = " + set2);
+
+        final Set<String> set3 = set2.add("foo");
+        System.out.println("set3 = " + set3);
+
+        final Set<String> set4 = set3.add("bar");
+        System.out.println("set4 = " + set4);
+
+        final Set<String> set5 = SetFactory.create("foo", "baz", "foo");
+        System.out.println("set5 = " + set5);
+
+        final Set<String> set6 = set4.union(set5);
+        System.out.println("set6 = " + set6);
+
+        final Set<String> set7 = set4.intersection(set5);
+        System.out.println("set7 = " + set7);
+
+        final Set<String> set8 = set5.intersection(set4);
+        System.out.println("set8 = " + set8);
+    }
+}

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<Object> EMPTY_SET = new EmptySet<>();
+
     private SetFactory() { /* don't instantiate */ }
 
     /**
@@ -11,7 +14,7 @@ public class SetFactory {
      * @return the empty set.
      */
     static <T> Set<T> create() {
-        return new EmptySet<T>();
+        return (Set<T>) EMPTY_SET;
     }
 
     /**
@@ -22,7 +25,7 @@ public class SetFactory {
      * @return the singleton set containing the specified element.
      */
     static <T> Set<T> create(T element) {
-        return new SingeltonSet<T>(element);
+        return new SingeltonSet<>(element);
     }
 
     /**

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<E> implements Set<E> {
+    private final E element;
 
-    private final E elem;
+    SingeltonSet(E element) {
-
+        this.element = Objects.requireNonNull(element);
-    public SingeltonSet(E elem) {
-        this.elem = elem;
-    }
-
-    @Override
-    public Iterator iterator() {
-        return new Iterator<E>() {
-
-            boolean returned = true;
-
-            @Override
-            public boolean hasNext() {
-                return returned;
-            }
-
-            @Override
-            public E next() {
-                if(!hasNext()) {
-                    throw new NoSuchElementException();
-                }
-
-                returned = false;
-                return elem;
-            }
-            
-        };
     }
 
     @Override
@@ -47,31 +23,67 @@ class SingeltonSet<E> implements Set<E> {
 
     @Override
     public boolean contains(Object el) {
-        return elem.equals(el);
+        return element.equals(el);
     }
 
     @Override
-    public Set union(Set other) {
+    public boolean subsetOf(Set<?> other) {
-        return other.add(elem);
+        return other.contains(element);
     }
 
     @Override
-    public Set add(Object element) {
+    public Set<E> union(Set<E> other) {
-        if (elem.equals(element)) {
+        return other.add(element);
+    }
+
+    @Override
+    public Set<E> add(E element) {
+        if (this.element.equals(element))
             return this;
-        }
+        return new BigSet<>(element, this);
-
-        return new BigSet(element, this);
     }
 
     @Override
-    public Set intersection(Set other) {
+    public Set<E> intersection(Set<E> other) {
-        return other.contains(elem) ? this : SetFactory.create();
+        return other.contains(element) ? this : SetFactory.create();
     }
 
     @Override
-    public boolean subsetOf(Set other) {
+    public Iterator<E> iterator() {
-        return other.contains(elem);
+        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 false;
+    }
 }

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<String> 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<String> 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<String> 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<String> oriIt = Arrays.asList("a", "b", null, "c").iterator();
+        final Iterator<String> it = new SkipNullIterator<>(oriIt);
+        while (it.hasNext())
+            System.out.println(it.next());
+    }
+
+    private static void demoSkipNullIteratorSingleton() {
+        System.out.println("SkipNullIterator [\"foo\"]");
+        final Iterator<String> oriIt = List.of("foo").iterator();
+        final Iterator<String> it = new SkipNullIterator<>(oriIt);
+        while (it.hasNext())
+            System.out.println(it.next());
+    }
+
+    private static void demoSkipNullIteratorInfinity() {
+        System.out.println("SkipNullIterator [\"infinity\", \"infinity\", ...]");
+        final Iterator<String> oriIt = new Iterator<>() {
+            @Override
+            public boolean hasNext() {
+                return true;
+            }
+
+            @Override
+            public String next() {
+                return "infinity";
+            }
+        };
+
+        final Iterator<String> 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<String> oriIt = new Iterator<>() {
+            private int ctr;
+
+            @Override
+            public boolean hasNext() {
+                return true;
+            }
+
+            @Override
+            public String next() {
+                return ctr++ > 100000 ? "infinity" : null;
+            }
+        };
+
+        final SkipNullIterator<String> 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();
+    }
+}