it compiles

pom.xml

          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
     <groupId>mygroupid</groupId>
     <artifactId>looptest</artifactId>
     <version>1.0-SNAPSHOT</version>

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

 
 import com.zipcodewilmington.streams.anthropoid.Person;
 import com.zipcodewilmington.streams.anthropoid.PersonFactory;
+import com.zipcodewilmington.streams.anthropoid.PersonWarehouse;
 import com.zipcodewilmington.streams.tools.RandomUtils;
 import com.zipcodewilmington.streams.tools.StringUtils;
 
+import java.util.Arrays;
 import java.util.List;
+import java.util.Random;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
     private final Stream<Person> personStream;
     public final String startingCharacter;
 
+
     /**
      * No arg constructor
      */ //TODO - construct person stream of 100 person objects; startingCharacter is a random capital letter
     public StreamFilter() {
-        this(Stream.empty(), null);
+        this(PersonFactory.createPersonArray(100), RandomUtils.createCharacter('A', 'Z'));
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(Person[] people, Character startingCharacter) {
-        this(Stream.empty(), null);
+        this(Arrays.asList(people), startingCharacter);
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(List<Person> people, Character startingCharacter) {
-        this(Stream.empty(), null);
+        this(people.stream(), startingCharacter);
     }
 
 
      * @return a list of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public List<Person> toListMultiLine() {
-        return null;
+        return personStream.filter(p -> {
+            return p.getName().startsWith(startingCharacter);
+        })
+        .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(p -> (p.getName().startsWith(startingCharacter))).collect(Collectors.toList());
     }
 
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayOneLine() {
-        return null;
+        List<Person> filteredList = toListOneLine();
+        return filteredList.toArray(new Person[filteredList.size()]);
     }
 
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayMultiLine() {
-        return null;
+        List<Person> filteredList = toListOneLine();
+        return filteredList.toArray(new Person[filteredList.size()]);
     }
 
 }

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 Stream.of(someWord.split(""));
     }
 
     /**
      * @return - a Stream of several Streams of single characters
      */ //TODO
     public static Stream<Stream<String>> wordsMap(String... someWords) {
-        return null;
+        return Stream.of(someWords).map(word -> letters(word));
     }
 
     /**
      * @return - a Stream of several Streams of single characters
      */ //TODO
     public static Stream<String> wordsFlatMap(String... stringArray) {
-        return null;
+        return Stream.of(stringArray).flatMap(word -> letters(word));
     }
 }

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

      * Section 8.8
      * @param listSize - number of Person objects to create
      * @return - ArrayList of Person objects
-     */ // TODO
+     */
     public static List<Person> createPersonList(int listSize) {
-        return null;
+        return Stream.generate(PersonFactory::createRandomPerson).limit(listSize).collect(Collectors.toList());
     }
 
 
     /**
      * @param arrayLength - number of Person objects to create
      * @return - Array of Person objects
-     */ // TODO
+     */
     public static Person[] createPersonArray(int arrayLength) {
-        return null;
+        return createPersonList(arrayLength).stream().toArray(Person[]::new);
     }
 
 
      * Section 8.2
      * @param streamCount - number of Person objects to create
      * @return - Stream representation of collection of Person objects
-     */ // TODO
+     */
     public static Stream<Person> createPersonStream(int streamCount) {
-        return null;
+        return Stream.generate(PersonFactory::createRandomPerson).limit(streamCount);
     }
 }

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

 import com.zipcodewilmington.streams.tools.logging.LoggerHandler;
 import com.zipcodewilmington.streams.tools.logging.LoggerWarehouse;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 
     /**
      * @return list of uniquely named Person objects
-     */ //TODO
+     */
     public static Stream<Person> getUniquelyNamedPeople() {
-        return null;
+        /*
+        HashMap<String, Person> uniqueMap = new HashMap<>();
+        people.stream().forEach(p -> uniqueMap.put(p.getName(), p));
+        return uniqueMap.entrySet().stream().map(e -> uniqueMap.get(e.getKey())).collect(Collectors.toList()).stream();
+        */
+        /*
+        List<Person> allNames = people.stream().map(p -> p.getName()).collect(Collectors.toList());
+        allNames = allNames.stream().distinct().collect(Collectors.toList());
+        */
+
+        return people.stream().collect(Collectors.toMap(Person::getName, p -> p, (p1, p2) -> p1)).values().stream();
     }
 
 
     /**
      * @param character starting character of Person objects' name
      * @return a Stream of respective
-     */ //TODO
+     */
     public static Stream<Person> getUniquelyNamedPeopleStartingWith(Character character) {
-        return null;
+        String startsWithChar = Character.toString(character);
+        return people.stream().distinct().filter(p -> (p.getName().startsWith(startsWithChar)));
     }
 
     /**
      * @param n first `n` Person objects
      * @return a Stream of respective
-     */ //TODO
+     */
     public static Stream<Person> getFirstNUniquelyNamedPeople(int n) {
-        return null;
+        return getUniquelyNamedPeople().limit(n);
     }
 
     /**
      * @return a mapping of Person Id to the respective Person name
-     */ // TODO
+     */
     public static Map<Long, String> getIdToNameMap() {
-        return null;
+        return people.stream().collect(Collectors.toMap(p -> p.getPersonalId(), p -> p.getName()));
     }
 
 
     /**
      * @return Stream of Stream of Aliases
-     */ // TODO
+     */
     public static Stream<Stream<String>> getNestedAliases() {
-        return null;
+        return people.stream().map(p -> Stream.of(p.getAliases()));
     }
 
 
     /**
      * @return Stream of all Aliases
-     */ // TODO
+     */
     public static Stream<String> getAllAliases() {
-        return null;
+        return people.stream().flatMap(p -> Stream.of(p.getAliases()));
     }
 
     /**
      * @return list of names of Person objects
-     */ // TODO
+     */
     public static List<String> getNames() {
-        return null;
+        return people.stream().map(p -> p.getName()).collect(Collectors.toList());
     }
 
     /**

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

  */
 public class TestPersonWarehouse {
 
+
     @Before
     public void setup() {
         PersonWarehouse.getPeople().clear();
-        PersonFactory.createPersonStream(999);
+        PersonFactory.createPersonStream(999).collect(Collectors.toList());
     }
 
     @Test