update

src/main/java/com/zipcodewilmington/streams/StreamFilter.java

 import com.zipcodewilmington.streams.anthropoid.Person;
 import com.zipcodewilmington.streams.anthropoid.PersonFactory;
 import com.zipcodewilmington.streams.tools.RandomUtils;
+import com.zipcodewilmington.streams.tools.StringUtils;
 
 import java.util.List;
 import java.util.stream.Collectors;
      * No arg constructor
      */ //TODO - construct person stream of 100 person objects; startingCharacter is a random capital letter
     public StreamFilter() {
-        this(PersonFactory.createPersonStream(100), RandomUtils.createCharacter('A', 'Z'));
+        this(PersonFactory.createPersonStream(999), RandomUtils.createCharacter('A', 'Z'));
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(List<Person> people, Character startingCharacter) {
-        this(people.stream(), startingCharacter);
+        this(people.parallelStream(), startingCharacter);
     }
 
 
      * @return a list of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public List<Person> toListMultiLine() {
-        Stream<Person> personStreamFiltered = personStream.filter(person -> person.name.getValue().startsWith(startingCharacter));
+        Stream<Person> personStreamFiltered = personStream.filter(person -> StringUtils.isPalindromeIgnoreCase(person.getName()));
         List list = personStreamFiltered.collect(Collectors.toList());
         return list;
     }
      */ //TODO
     public List<Person> toListOneLine() {
         return personStream
-                .filter(person -> person.name.getValue().startsWith(startingCharacter))
+                .filter(person -> StringUtils.isPalindromeIgnoreCase(person.getName()))
                 .collect(Collectors.toList());
     }
 
      */ //TODO
     public Person[] toArrayOneLine() {
         return personStream
-                .filter(person -> person.name.getValue().startsWith(startingCharacter))
+                .filter(person -> StringUtils.isPalindromeIgnoreCase(person.getName()))
                 .toArray(Person[]::new); // method reference
     }
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayMultiLine() {
-        Stream<Person> personStreamFiltered = personStream.filter(person -> person.name.getValue().startsWith(startingCharacter));
+        Stream<Person> personStreamFiltered = personStream.filter(person -> StringUtils.isPalindromeIgnoreCase(person.getName()));
         Person[] personArray = personStreamFiltered.toArray(Person[]::new); // method reference
         return personArray;
     }

src/main/java/com/zipcodewilmington/streams/StreamMap.java

 package com.zipcodewilmington.streams;
 
+import com.zipcodewilmington.streams.anthropoid.Person;
+import com.zipcodewilmington.streams.conversions.StreamConverter;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
         return Stream.of(someWords).map(w -> letters(w));
     }
 
-    //TODO
-    public static Stream<Stream<String>> wordsFlatMap(String... someWords) {
-        return null;//Arrays.asList(someWords).stream().flatMap(w -> letters(w));
+    /**
+     * @param stringArray - variable amount of String arguments
+     * @return - a Stream of several Streams of single characters
+     */ //TODO
+    public static Stream<String> wordsFlatMap(String... stringArray) {
+        Stream<String> wordStream = Stream.of(stringArray);
+        List<String> wordList = wordStream.collect(Collectors.toList());
+        return wordList.stream().flatMap(w -> letters(w));
     }
 }

src/main/java/com/zipcodewilmington/streams/anthropoid/Person.java

 package com.zipcodewilmington.streams.anthropoid;
 
+import com.zipcodewilmington.streams.tools.DateUtils;
+
+import java.time.LocalDate;
+import java.time.Period;
 import java.util.Date;
 
 /**
  * @ATTENTION_TO_STUDENTS You are FORBIDDEN from modifying this class
  */
 public class Person {
-    public final PersonProperty<String> name;
-    public final PersonProperty<Integer> age;
-    public final PersonProperty<Boolean> isMale;
-    public final PersonProperty<Long> personalId;
-    public final PersonProperty<Date> birthDate;
-    public final PersonProperty<String[]> aliases;
-
+    public final String name;
+    public final int age;
+    public final boolean isMale;
+    public final long personalId;
+    public final Date birthDate;
+    public final String[] aliases;
     /**
      * @param name - name of person
      * @param age - age of person
      * @param personalId - unique id
      * @param birthDate - date of birth
      */
-    public Person(String name, int age, boolean isMale, long personalId, Date birthDate, String... aliases) {
-        this.name = new PersonProperty<>(name);
-        this.age = new PersonProperty<>(age);
-        this.isMale = new PersonProperty<>(isMale);
-        this.personalId = new PersonProperty<>(personalId);
-        this.birthDate = new PersonProperty<>(birthDate);
-        this.aliases = new PersonProperty<>(aliases);
+    Person(String name, int age, boolean isMale, long personalId, Date birthDate, String... aliases) {
+        this.name = name;
+        this.isMale = isMale;
+        this.personalId = personalId;
+        this.birthDate = birthDate;
+        this.age = DateUtils.yearsBetween(birthDate, LocalDate.now());
+        this.aliases = aliases;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public boolean isMale() {
+        return isMale;
+    }
+
+    public long getPersonalId() {
+        return personalId;
+    }
+
+    public Date getBirthDate() {
+        return birthDate;
     }
 
-    /** the purpose of this class is to compress verbose getter and setter logic
-     * @param <E> the type of data to store */
-    public class PersonProperty<E> {
-        private E val; // value of the data
-
-        /** @param val - value of data for this object to store */
-        public PersonProperty(E val) {
-            this.val = val;
-        }
-
-        /** @return value this object is storing */
-        public E getValue() {
-            return val;
-        }
-
-        /** set value this object is storing */
-        public void setValue(E val) {
-            this.val = val;
-        }
+    public String[] getAliases() {
+        return aliases;
     }
 }

src/main/java/com/zipcodewilmington/streams/anthropoid/PersonFactory.java

      * @return a new instance of a person with fields of random values
      */
     public static Person createRandomPerson() {
-        String name = StringUtils.capitalizeFirstChar(RandomUtils.createString('a', 'z', 10));
-        String[] aliases = RandomUtils.createStrings('a', 'z', 10, 100);
+        String name = StringUtils.capitalizeFirstChar(RandomUtils.createString('a', 'z', 3));
+        String[] aliases = RandomUtils.createStrings('a', 'z', 5, 5);
         int age = RandomUtils.createInteger(0, 99);
         boolean isMale = RandomUtils.createBoolean(50);
         long personalId = System.nanoTime();
 
 
         Person randomPerson = new Person(name, age, isMale, personalId, birthDate, aliases);
+        PersonWarehouse.addPerson(randomPerson);
         return randomPerson;
     }
 

src/main/java/com/zipcodewilmington/streams/anthropoid/PersonWarehouse.java

+package com.zipcodewilmington.streams.anthropoid;
+
+import com.zipcodewilmington.streams.tools.ReflectionUtils;
+import com.zipcodewilmington.streams.tools.logging.LoggerHandler;
+import com.zipcodewilmington.streams.tools.logging.LoggerWarehouse;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Created by leon on 5/29/17.
+ * The warehouse is responsible for storing, retrieving, and filtering people
+ */
+public class PersonWarehouse {
+    private static final LoggerHandler loggerHandler = LoggerWarehouse.getLogger(PersonWarehouse.class);
+    private static ArrayList<Person> people = new ArrayList<>();
+
+    public static void addPerson(Person person) {
+        loggerHandler.disbalePrinting();
+        loggerHandler.info("Registering a new person object to the person warehouse...");
+        loggerHandler.info(ReflectionUtils.getFieldMap(person).toString());
+        people.add(person);
+    }
+
+    /**
+     * @return list of uniquely named Person objects
+     */ //TODO
+    public static Stream<Person> getUniquelyNamedPeople() {
+        ArrayList<String> names = new ArrayList<>();
+        return people.parallelStream().filter(
+                person -> !names.contains(person.getName()));
+    }
+
+    /**
+     * @param character starting character of Person objects' name
+     * @return a Stream of respective
+     */ //TODO
+    public static Stream<Person> getUniquelyNamedPeopleStartingWith(Character character) {
+        return getUniquelyNamedPeople().filter(
+                person -> person.getName().startsWith(character.toString()));
+    }
+
+    /**
+     * @param n starting character of Person objects' name
+     * @return a Stream of respective
+     */ //TODO
+    public static Stream<Person> getFirstNUniquelyNamedPeople(int n) {
+        return getUniquelyNamedPeople().limit(n);
+    }
+
+    /**
+     * @return a mapping of Person Id to the respective Person name
+     */ // TODO
+    public static Map<Long, String> getIdToNameMap() {
+        return people.parallelStream().collect(
+                Collectors.toMap(p -> p.getPersonalId(), p -> p.getName()));
+    }
+}

src/main/java/com/zipcodewilmington/streams/conversions/ConversionAgent.java

 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
-
 /**
  * Created by leon on 5/25/17.
- * ConversionAgent is responsible for conversion between different collection types
- * for the sake of this assignment and my sanity, consider primitive arrays to be collection type
+ * ConversionAgent is responsible for conversion between different object sequent data types
+ * Object sequent data types include: collections, arrays, lists, maps, iterators
  */
 public abstract class ConversionAgent<T> {
     protected T people;
 
-    public ConversionAgent(T val) {
-        this.people = val;
+    public ConversionAgent(T objectSequence) {
+        this.people = objectSequence;
     }
 
     abstract public List<Person> toList();

src/main/java/com/zipcodewilmington/streams/conversions/StreamConverter.java

 
     // TODO
     public Stream<Person> toStream() {
-        return this.personList.stream();
+        return this.personList.parallelStream();
     }
 
     // TODO

src/main/java/com/zipcodewilmington/streams/tools/DateUtils.java

+package com.zipcodewilmington.streams.tools;
+
+import java.time.*;
+import java.util.Date;
+
+/**
+ * Created by leon on 5/1/17.
+ * @ATTENTION_TO_STUDENTS You are FORBIDDEN from modifying this class
+ */
+public final class DateUtils {
+    private DateUtils() {
+        /** this class is uninstantiable */
+    }
+
+    /**
+     * @param localDate LocalDate object to convert
+     * @return respective Date-object-representation
+     */
+    public static Date asDate(LocalDate localDate) {
+        return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
+    }
+
+    public static Date asDate(LocalDateTime localDateTime) {
+        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
+    }
+
+    public static LocalDate asLocalDate(Date date) {
+        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
+    }
+
+    public static LocalDateTime asLocalDateTime(Date date) {
+        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
+    }
+
+    public static int yearsBetween(Date startDate, Date endDate) {
+        return yearsBetween(DateUtils.asLocalDate(startDate), DateUtils.asLocalDate(endDate));
+    }
+
+    public static int yearsBetween(Date startDate, LocalDate endDate) {
+        return yearsBetween(DateUtils.asLocalDate(startDate), endDate);
+    }
+
+    public static int yearsBetween(LocalDate startDate, LocalDate endDate) {
+        return Period.between(startDate, endDate).getYears();
+    }
+}

src/main/java/com/zipcodewilmington/streams/tools/ReflectionUtils.java

             try {
                 boolean defaultAccess = f.isAccessible();
 
-                // attempt to modify visibility
+                // attempt to modify field visibility
                 f.setAccessible(true);
                 hm.put(f, f.get(object).toString());
                 f.setAccessible(defaultAccess);

src/main/java/com/zipcodewilmington/streams/tools/StringUtils.java

      * @return the padded-left String
      */
     public static String padRight(String s, int n) {
-        return String.format("%1$-" + n + "s", s);
+        return padLeft(s, -n);
+    }
+
+    public static boolean isPalindromeIgnoreCase(String str) {
+        return new StringBuilder(str).reverse().toString().equalsIgnoreCase(str);
     }
 }

src/main/java/com/zipcodewilmington/streams/tools/logging/LoggerHandler.java

+package com.zipcodewilmington.streams.tools.logging;
+
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.logging.*;
+import java.util.stream.Stream;
+
+import static java.util.logging.Level.*;
+
+/**
+ * Created by leon on 5/15/17.
+ */
+public final class LoggerHandler {
+    private final Logger logger;
+    private final String loggerName;
+    private boolean printingEnabled;
+
+    public LoggerHandler(Class c) {
+        this(c.getSimpleName());
+    }
+
+    public LoggerHandler(String loggerName) {
+        this(Logger.getLogger(loggerName));
+    }
+
+    public LoggerHandler(Logger logger) {
+        this.logger = logger;
+        this.loggerName = logger.getName();
+        this.logger.addHandler(getFileHandler());
+        this.printingEnabled = true;
+    }
+
+    public void throwable(Throwable t, Level level) {
+        StringWriter out = new StringWriter();
+        t.printStackTrace(new PrintWriter(out));
+        String description = out.toString();
+        log(level, description);
+    }
+
+    public void throwable(Throwable t) {
+        throwable(t, WARNING);
+    }
+
+    public void info(String s, Object... args) {
+        log(INFO, s, args);
+    }
+
+    public void warn(String s, Object... args) {
+        log(WARNING, String.format(s, args));
+    }
+
+    public void error(String s, Object... args) {
+        log(SEVERE, s, args);
+    }
+
+    private void log(Level level, String message, Object... messageArgs) {
+        if(printingEnabled) {
+            System.out.println(String.format(message, messageArgs));
+        }
+        logger.log(level, String.format(message, messageArgs));
+    }
+
+    public void setLevel(Level level) {
+        logger.setLevel(level);
+    }
+
+    public void enablePrinting() {
+        this.printingEnabled = true;
+    }
+
+    public void disbalePrinting() {
+        this.printingEnabled = false;
+    }
+
+    private FileHandler getFileHandler() {
+        return getFileHandler(new SimpleFormatter());
+    }
+
+    private FileHandler getFileHandler(Formatter formatter) {
+        FileHandler fh = null;
+        try {
+            removeHandlers(); // enables better printing control
+            String fileName = String.format("./target/%s.leonlog", loggerName, System.nanoTime());
+            fh = new FileHandler(fileName);
+            fh.setFormatter(formatter);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        } catch (NullPointerException npe) {
+
+        }
+        return fh;
+    }
+
+    private void removeHandlers() {
+        logger.setUseParentHandlers(false);
+        for (Handler handler : logger.getHandlers()) {
+            logger.removeHandler(handler);
+        }
+    }
+}

src/main/java/com/zipcodewilmington/streams/tools/logging/LoggerWarehouse.java

+package com.zipcodewilmington.streams.tools.logging;
+
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ * Created by leon on 5/15/17.
+ */
+public class LoggerWarehouse {
+    public static final LoggerHandler globalLogger = new LoggerHandler(Logger.getGlobal());
+    private static final HashMap<Class, LoggerHandler> loggerMap = new HashMap<>();
+
+    public static final LoggerHandler getLogger(Class c) {
+        addLogger(c);
+        return loggerMap.get(c);
+    }
+
+    private static final void addLogger(Class c) {
+        if (!loggerMap.containsKey(c)) {
+            globalLogger.info(String.format("Instantiating logger for [ %s ] ... ", c.getName()));
+            loggerMap.put(c, new LoggerHandler(c));
+        }
+    }
+}

src/test/java/com/zipcodewilmington/streams/TestStreamFilter.java

 package com.zipcodewilmington.streams;
 
 import com.zipcodewilmington.streams.anthropoid.Person;
+import com.zipcodewilmington.streams.tools.StringUtils;
+import com.zipcodewilmington.streams.tools.logging.LoggerHandler;
+import com.zipcodewilmington.streams.tools.logging.LoggerWarehouse;
 import org.junit.Before;
 import org.junit.Test;
 
     }
 
     private void testFilter(List<Person> persons) {
+        assert(persons.size() > 0);
         for (Person p : persons) {
-            assert (p.name.getValue().startsWith(streamFilter.startingCharacter));
+            assert (StringUtils.isPalindromeIgnoreCase(p.getName()));
         }
     }
 }

src/test/java/com/zipcodewilmington/streams/anthropoid/TestPerson.java

 
 /**
  * Created by leon on 5/25/17.
+ *
  * @ATTENTION_TO_STUDENTS You are FORBIDDEN from modifying this class
  */
 public class TestPerson {
-}
+}

src/test/java/com/zipcodewilmington/streams/anthropoid/TestPersonFactory.java

         checkStream(PersonFactory.createPersonStream(collectionSize));
     }
 
+    //8.1 - 8.6; 8.7 - rest
     private final void checkStream(Stream<Person> personStream) {
         String messageCheckSize = "Ensuring appropriately sized stream was produced.";
 
         Person[] personArray = personStream.toArray(Person[]::new);
         Assert.assertEquals(messageCheckSize, collectionSize, personArray.length);
-        for (Person person : personArray) { // TODO - Move to a `TestPerson` class
+        for (Person person : personArray) {
            checkPerson(person);
         }
     }
         String messageCheckValue = "Ensuring field-value is non-null";
 
         HashMap<Field, String> fieldMap = ReflectionUtils.getFieldMap(person);
-        System.out.println(fieldMap.toString());
         for (Map.Entry<Field, String> entry : fieldMap.entrySet()) {
             Field key = entry.getKey();
             String value = entry.getValue();

src/test/java/com/zipcodewilmington/streams/conversions/TestConversionAgent.java

     @Test
     public void testToList() {
         for (int i = 0; i < personList.size(); i++) {
-            long listId = personList.get(i).personalId.getValue();
-            long arrayId = personArray[i].personalId.getValue();
+            long listId = personList.get(i).getPersonalId();
+            long arrayId = personArray[i].getPersonalId();
 
             Assert.assertEquals(listId, arrayId);
         }
         List<Person> people = personStream.collect(Collectors.toList());
 
         for (int i = 0; i < people.size(); i++) {
-            long arrayId = personArray[i].personalId.getValue();
-            long streamId = people.get(i).personalId.getValue();
+            long arrayId = personArray[i].getPersonalId();
+            long streamId = people.get(i).getPersonalId();
 
             Assert.assertEquals(streamId, arrayId);
         }
     @Test
     public void testToArray() {
         for (int i = 0; i < personArray.length; i++) {
-            long arrayId = personArray[i].personalId.getValue();
-            long listId = personList.get(i).personalId.getValue();
+            long arrayId = personArray[i].getPersonalId();
+            long listId = personList.get(i).getPersonalId();
 
             Assert.assertEquals(listId, arrayId);
         }

target/global.leonlog

+May 30, 2017 4:24:18 PM com.zipcodewilmington.streams.tools.logging.LoggerHandler log
+INFO: Instantiating logger for [ com.zipcodewilmington.streams.anthropoid.PersonWarehouse ] ...