all tests pass except one for a class we're not allowed to edit :P

.idea/compiler.xml

         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
         <module name="looptest" />
+        <module name="streamdemo" />
       </profile>
     </annotationProcessing>
     <bytecodeTargetLevel target="1.8">
-      <module name="looptest" target="1.8" />
+      <module name="streamdemo" target="8" />
     </bytecodeTargetLevel>
   </component>
 </project>

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

 import com.zipcodewilmington.streams.tools.RandomUtils;
 import com.zipcodewilmington.streams.tools.StringUtils;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
      * No arg constructor
      */ //TODO - construct person stream of 100 person objects; startingCharacter is a random capital letter
     public StreamFilter() {
-        this(Stream.empty(), null);
+        //this(Stream.empty(), null);
+        personStream = PersonFactory.createPersonStream(100);
+        startingCharacter = String.valueOf((char) 'A' + (Math.random()) * 26);
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(Person[] people, Character startingCharacter) {
-        this(Stream.empty(), null);
+        personStream = Arrays.stream(people);
+        this.startingCharacter = String.valueOf(startingCharacter);
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(List<Person> people, Character startingCharacter) {
-        this(Stream.empty(), null);
+        personStream = people.stream();
+        this.startingCharacter = String.valueOf(startingCharacter);
     }
 
 
      * @return a list of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public List<Person> toListMultiLine() {
-        return null;
+        Predicate<Person> startsWithChar = person -> person.getName().matches("^" + this.startingCharacter);
+        return personStream.filter(startsWithChar).collect(Collectors.toList());
     }
 
 
      * @return a list of person objects whose name starts with `this.startingCharacter`
      */ //TODO
     public List<Person> toListOneLine() {
-        return null;
+        return personStream.filter(person -> person.getName().matches("^" + this.startingCharacter)).collect(Collectors.toList());
     }
 
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayOneLine() {
-        return null;
+        return personStream.filter(person -> person.getName().matches("^" + this.startingCharacter)).toArray(Person[]::new);
     }
 
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayMultiLine() {
-        return null;
+        Predicate<Person> startsWithChar = person -> person.getName().matches("^" + this.startingCharacter);
+        return personStream.filter(startsWithChar).toArray(Person[]::new);
     }
 
 }

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

      * @return - a Stream of single characters
      */ //TODO
     public static Stream<String> letters(String someWord) {
-        return null;
+        return Arrays.stream(someWord.split(""));
     }
 
     /**
      * @return - a Stream of several Streams of single characters
      */ //TODO
     public static Stream<Stream<String>> wordsMap(String... someWords) {
-        return null;
+        return Arrays.stream(someWords).map(StreamMap::letters);
     }
 
     /**
      * @return - a Stream of several Streams of single characters
      */ //TODO
     public static Stream<String> wordsFlatMap(String... stringArray) {
-        return null;
+        return Arrays.stream(stringArray).flatMap(StreamMap::letters);
     }
 }

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

 import com.zipcodewilmington.streams.tools.RandomUtils;
 import com.zipcodewilmington.streams.tools.StringUtils;
 
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.stream.Collectors;
      * @return - ArrayList of Person objects
      */ // TODO
     public static List<Person> createPersonList(int listSize) {
-        return null;
+        return createPersonStream(listSize).collect(Collectors.toList());
     }
 
 
      * @return - Array of Person objects
      */ // TODO
     public static Person[] createPersonArray(int arrayLength) {
-        return null;
+        return createPersonList(arrayLength).toArray(new Person[arrayLength]);
     }
 
 
      * @return - Stream representation of collection of Person objects
      */ // TODO
     public static Stream<Person> createPersonStream(int streamCount) {
-        return null;
+        return Stream.generate(() -> createRandomPerson()).limit(streamCount);
     }
 }

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

      * @return list of uniquely named Person objects
      */ //TODO
     public static Stream<Person> getUniquelyNamedPeople() {
-        return null;
+        return people.stream().distinct();
     }
 
 
+
     /**
      * @param character starting character of Person objects' name
      * @return a Stream of respective
      */ //TODO
     public static Stream<Person> getUniquelyNamedPeopleStartingWith(Character character) {
-        return null;
+        return getUniquelyNamedPeople().filter(person -> person.getName().matches("^"+character));
     }
 
     /**
      * @return a Stream of respective
      */ //TODO
     public static Stream<Person> getFirstNUniquelyNamedPeople(int n) {
-        return null;
+        return getUniquelyNamedPeople().limit(n);
     }
 
     /**
      * @return list of names of Person objects
      */ // TODO
     public static List<String> getNames() {
-        return null;
+        return people.stream().map(person -> person.getName()).collect(Collectors.toList());
     }
 
     /**

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

 import com.zipcodewilmington.streams.anthropoid.Person;
 import com.zipcodewilmington.streams.anthropoid.PersonFactory;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
 
     //TODO
     public List<Person> toList() {
-        return null;
+
+        return Arrays.asList(objectSequence);
     }
 
     //TODO
     public Stream<Person> toStream() {
-        return null;
+        return Arrays.stream(objectSequence);
     }
 
     @Override

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

 
     //TODO
     public Stream<Person> toStream() {
-        return null;
+        return objectSequence.stream();
     }
 
     //TODO
     public Person[] toArray() {
-        return null;
+        return objectSequence.toArray(new Person[objectSequence.size()]);
     }
 }

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

 
     // TODO
     public List<Person> toList() {
-        return null;
+        return personList.stream().collect(Collectors.toList());
     }
 
     // TODO
     public Stream<Person> toStream() {
-        return null;
+        return personList.stream();
     }
 
     // TODO
     public Person[] toArray() {
-        return null;
+        return personList.stream().toArray(Person[]::new);
     }
 }

target/global.leonlog

-May 31, 2017 4:45:59 PM com.zipcodewilmington.streams.tools.logging.LoggerHandler log
+Jun 28, 2018 5:09:36 PM com.zipcodewilmington.streams.tools.logging.LoggerHandler log
 INFO: Instantiating logger for [ com.zipcodewilmington.streams.anthropoid.PersonWarehouse ] ...