complete linked list and printable linked list

Author: ymzong

src/section21/MapperFn.java

@@ -1,10 +1,10 @@
 package section21;
 
 /**
- * This interface encapsulates a function that maps type T to U, and it can be used for funciton-as-value as in
+ * This interface encapsulates a function that maps type T to U, and it can be used for function-as-value as in
  * functional programming.
  *
- * Java 8 now includes Function<T,U> under java.util.function package.
+ * Java 8 now includes Function<T,U> under java.util.function package for exactly this.
  */
 public interface MapperFn<T,U> {
 

src/section21/MyLinkedList.java

@@ -5,7 +5,7 @@
 /**
  * This class implements a generic doubly-linked list with common operations.
  */
-public class MyLinkedList<T> implements Iterable<T> {
+public class MyLinkedList<T> implements MyList<T> {
 
     /**
      * Static nested class that presents a node in the linked list; also generic.
@@ -147,6 +147,15 @@ public T getTailValue() {
         return tail.value;
     }
 
+    /* Creates a new linked list by mapping each of its elements */
+    public <U> MyList<U> map(MapperFn<T,U> fn) {
+        MyLinkedList<U> newList = new MyLinkedList<>();
+        for (T elem : this) {
+            newList.append(fn.call(elem));
+        }
+        return newList;
+    }
+
     /* Get an iterator for the current state of the linked list */
     public Iterator<T> iterator() {
         return new Iterator<T>() {

src/section21/MyPrintableList.java

@@ -0,0 +1,30 @@
+package section21;
+
+import java.io.PrintWriter;
+
+/**
+ * A generic printable list that extends MyLinkedList<T> and adds a print() method to make it printable.
+ * Type argument constraint (`T extends PrintableObj`) makes sure that each element is printable.
+ */
+public class MyPrintableList<T extends PrintableObj> extends MyLinkedList<T> implements PrintableObj, MyList<T> {
+
+    /* This method prints all contents of the linked list to the PrintWriter */
+    public void print(PrintWriter fs) {
+        for (T elem : this) {   // this syntax is possible since MyLinkedList implements MyList<T> (hence Iterable<T>)
+            fs.print(elem);
+        }
+    }
+
+}
+
+/**
+ * This interface represents an object that has print method that prints itself to the PrintWriter as provided.
+ */
+interface PrintableObj {
+
+    /**
+     * Prints itself to the provided PrintWriter.
+     * @param fs target PrintWriter
+     */
+    void print(PrintWriter fs);
+}

src/section21/MyPrintableListExample.java

@@ -0,0 +1,44 @@
+package section21;
+
+import java.io.PrintWriter;
+
+/**
+ * This example uses MyPrintableList declared earlier.
+ */
+public class MyPrintableListExample {
+
+    public static void main(String[] argv) {
+        MyPrintableList<PrintableInteger> myList = new MyPrintableList<>();
+        myList.append(new PrintableInteger(2));
+        myList.append(new PrintableInteger(3));
+        myList.append(new PrintableInteger(5));
+        myList.append(new PrintableInteger(7));
+
+        PrintWriter stdout = new PrintWriter(System.out);
+        PrintWriter stderr = new PrintWriter(System.err);
+        myList.print(stdout);
+        myList.print(stderr);
+        stdout.flush();
+        stderr.flush();
+    }
+}
+
+/**
+ * PrintableInteger simply holds an immutable integer, and defines a toString() method to be used by print(PrintWriter).
+ */
+class PrintableInteger implements PrintableObj {
+
+    public final int val;       // intentionally immutable
+
+    public PrintableInteger(int val) {
+        this.val = val;
+    }
+
+    public void print(PrintWriter fs) {
+        fs.write(val);          // what's written to `fs` is determined by its toString method
+    }
+
+    public String toString() {
+        return String.format("PrintableInteger(val=%d)", val);
+    }
+}