completed file

.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>

.idea/libraries/Maven__junit_junit_4_12.xml

-<component name="libraryTable">
-  <library name="Maven: junit:junit:4.12">
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12-javadoc.jar!/" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/libraries/Maven__junit_junit_4_13_beta_1.xml

+<component name="libraryTable">
+  <library name="Maven: junit:junit:4.13-beta-1">
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13-beta-1/junit-4.13-beta-1.jar!/" />
+    </CLASSES>
+    <JAVADOC>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13-beta-1/junit-4.13-beta-1-javadoc.jar!/" />
+    </JAVADOC>
+    <SOURCES>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13-beta-1/junit-4.13-beta-1-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

pom.xml

     <groupId>mygroupid</groupId>
     <artifactId>looptest</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
     <dependencies>
         <dependency>
             <groupId>junit</groupId>

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

 import com.zipcodewilmington.streams.tools.RandomUtils;
 import com.zipcodewilmington.streams.tools.StringUtils;
 
+import java.util.Arrays;
 import java.util.List;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
  */
 public class StreamFilter {
     private final Stream<Person> personStream;
-    public final String startingCharacter;
+    private 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.createPersonStream(10), RandomUtils.createCharacter('A','Z'));
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(Person[] people, Character startingCharacter) {
-        this(Stream.empty(), null);
+
+        this(Arrays.stream(people), startingCharacter);
     }
 
     /**
      * @param startingCharacter - character to filter by
      */ //TODO
     public StreamFilter(List<Person> people, Character startingCharacter) {
-        this(Stream.empty(), null);
+        this(people.stream(), startingCharacter);
     }
 
 
      * @param people - Stream of person objects
      * @param startingCharacter - character to filter by
      */ // I took care of the easy constructor (͡° ͜ʖ ͡°)
+
     public StreamFilter(Stream<Person> people, Character startingCharacter) {
         this.personStream = people;
         this.startingCharacter = startingCharacter.toString();
      * @return a list of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public List<Person> toListMultiLine() {
-        return null;
+
+
+        Predicate<Person> filter = person -> StringUtils.isPalindromeIgnoreCase(person.getName());
+         return personStream
+             .filter(filter)
+             .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 -> StringUtils.isPalindromeIgnoreCase(person.getName())).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 -> StringUtils.isPalindromeIgnoreCase(person.getName())).toArray(Person[]::new);
     }
 
 
      * @return an array of person object whose name starts with `this.startingCharacter`
      */ //TODO
     public Person[] toArrayMultiLine() {
-        return null;
+        return personStream.filter(person -> {StringBuilder reverseName = new StringBuilder();
+          for (int i = person.getName().length() - 1; i > 0; i--) {
+               reverseName.append(person.getName().charAt(i));
+              } return reverseName.toString().equalsIgnoreCase(person.getName());
+         }).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;
+        String[] characters = someWord.split("");
+        return Arrays.stream(characters);
     }
 
     /**
      * @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

      * @return - ArrayList of Person objects
      */ // TODO
     public static List<Person> createPersonList(int listSize) {
-        return null;
+            Stream<Person> personStream = Stream.generate(PersonFactory::createRandomPerson).limit(listSize);
+            return personStream.collect(Collectors.toList());
     }
 
 
      * @return - Array of Person objects
      */ // TODO
     public static Person[] createPersonArray(int arrayLength) {
-        return null;
+        Stream<Person> personStream = Stream.generate(PersonFactory::createRandomPerson).limit(arrayLength);
+        return personStream.toArray(Person[]::new);
     }
 
 
      * @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

      * @return list of uniquely named Person objects
      */ //TODO
     public static Stream<Person> getUniquelyNamedPeople() {
-        return null;
+        return people.stream().distinct();
     }
 
 
      * @return a Stream of respective
      */ //TODO
     public static Stream<Person> getUniquelyNamedPeopleStartingWith(Character character) {
-        return null;
+        return people.stream().distinct().filter(person -> person.getName().charAt(0) == character);
     }
 
     /**
      * @return a Stream of respective
      */ //TODO
     public static Stream<Person> getFirstNUniquelyNamedPeople(int n) {
-        return null;
+
+        return people.stream().distinct().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(Person::getPersonalId, Person::getName));
     }
 
 

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

 
 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 Stream.of(super.objectSequence).collect(Collectors.toList());
     }
 
     //TODO
     public Stream<Person> toStream() {
-        return null;
+        return Stream.of(super.objectSequence);
     }
 
     @Override

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

 
     @Override
     public List<Person> toList() {
+
         return super.objectSequence;
     }
 
     //TODO
     public Stream<Person> toStream() {
-        return null;
+
+        return super.objectSequence.stream();
     }
 
     //TODO
     public Person[] toArray() {
-        return null;
+        return super.objectSequence.stream().toArray(Person[]::new);
     }
 }

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

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

streamdemo.iml

     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="Maven: junit:junit:4.12" level="project" />
+    <orderEntry type="library" name="Maven: junit:junit:4.13-beta-1" level="project" />
     <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
   </component>
 </module>