converted project to lambda exercise

.idea/compiler.xml

         <module name="looptest" />
       </profile>
     </annotationProcessing>
-    <bytecodeTargetLevel>
-      <module name="looptest" target="1.5" />
+    <bytecodeTargetLevel target="1.8">
+      <module name="looptest" target="1.8" />
     </bytecodeTargetLevel>
   </component>
 </project>

.idea/misc.xml

   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
-  <component name="masterDetails">
-    <states>
-      <state key="ScopeChooserConfigurable.UI">
-        <settings>
-          <splitter-proportions>
-            <option name="proportions">
-              <list>
-                <option value="0.2" />
-              </list>
-            </option>
-          </splitter-proportions>
-        </settings>
-      </state>
-    </states>
-  </component>
 </project>

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

looptest.iml

 <?xml version="1.0" encoding="UTF-8"?>
 <module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_5">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
     <output url="file://$MODULE_DIR$/target/classes" />
     <output-test url="file://$MODULE_DIR$/target/test-classes" />
     <content url="file://$MODULE_DIR$">

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

 /**
  * Created by leon on 5/2/17.
  */
-public class LambdaFilter {
+public class StreamFilter {
     private final Stream<Person> personStream;
     public final String startingCharacter;
 
     /**
      * No arg constructor
      */
-    public LambdaFilter() {
+    public StreamFilter() {
         this(PersonFactory.createPersonStream(100), 'A');
     }
 
      * @param people - Array of person objects
      * @param startingCharacter - character to filter by
      */
-    public LambdaFilter(Person[] people, Character startingCharacter) {
+    public StreamFilter(Person[] people, Character startingCharacter) {
         this(Stream.of(people), startingCharacter);
     }
 
      * @param people - List of person objects
      * @param startingCharacter - character to filter by
      */
-    public LambdaFilter(List<Person> people, Character startingCharacter) {
+    public StreamFilter(List<Person> people, Character startingCharacter) {
         this(people.stream(), startingCharacter);
     }
 
      * @param people - Stream of person objects
      * @param startingCharacter - character to filter by
      */
-    public LambdaFilter(Stream<Person> people, Character startingCharacter) {
+    public StreamFilter(Stream<Person> people, Character startingCharacter) {
         this.personStream = people;
         this.startingCharacter = startingCharacter.toString();
     }

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

 package com.zipcodewilmington.lambdas;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 /**
  * Created by leon on 5/24/17.
  */
-public class MapSyntax {
+public class StreamMap {
+    /**
+     * @param someWord - word to convert to Stream<String>
+     * @return - a Stream of single characters
+     */
+    public static Stream<String> letters(String someWord) {
+        return Stream.of(someWord.split(""));
+    }
+
+    /**
+     * @param someWords - variable amount of String arguments
+     * @return - a Stream of several Streams of single characters
+     */
+    public static Stream<Stream<String>> wordsMap(String... someWords) {
+        return Stream.of(someWords).map(w -> letters(w));
+    }
+
+    public static Stream<Stream<String>> wordsFlatMap(String... someWords) {
+        return null;//Arrays.asList(someWords).stream().flatMap(w -> letters(w));
+    }
 }

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

-package com.zipcodewilmington.lambdas.tools.anthropoid;
+package com.zipcodewilmington.lambdas.anthropoid;
 
 import java.util.Date;
 
     public final PersonProperty<Boolean> isMale;
     public final PersonProperty<Long> personalId;
     public final PersonProperty<Date> birthDate;
+    public final PersonProperty<String[]> aliases;
 
     /**
      * @param name - name of person
      * @param personalId - unique id
      * @param birthDate - date of birth
      */
-    public Person(String name, int age, boolean isMale, long personalId, Date birthDate) {
+    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);
     }
 
     /** the purpose of this class is compress verbose getter and setter logic

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

-package com.zipcodewilmington.lambdas.tools.anthropoid;
+package com.zipcodewilmington.lambdas.anthropoid;
 
 import com.zipcodewilmington.lambdas.tools.RandomUtils;
 import com.zipcodewilmington.lambdas.tools.StringUtils;
 
-import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.stream.Collectors;
 /**
  * Created by leon on 5/1/17.
  */
-public class PersonFactory {
+public final class PersonFactory {
+    private PersonFactory() {
+        /** this class is not to be instantiated */
+    }
+
     /**
      * @return a new instance of a person with randomized fields
      */
     public static Person createRandomPerson() {
         String name = StringUtils.capitalizeFirstChar(RandomUtils.createString('a', 'z', 10));
+        String[] aliases = RandomUtils.createStrings('a', 'z', 10, 100);
         int age = RandomUtils.createInteger(0, 99);
-        boolean isMale = RandomUtils.chance(50);
+        boolean isMale = RandomUtils.createBoolean(50);
         long personalId = System.nanoTime();
         Date birthDate = RandomUtils.createDate(1950, 2010);
 
-        Person randomPerson = new Person(name, age, isMale, personalId, birthDate);
+
+        Person randomPerson = new Person(name, age, isMale, personalId, birthDate, aliases);
         return randomPerson;
     }
 

src/main/java/com/zipcodewilmington/lambdas/exercises/ArrayConversion.java

-package com.zipcodewilmington.lambdas;
+package com.zipcodewilmington.lambdas.exercises;
 
 import com.zipcodewilmington.lambdas.anthropoid.Person;
 
 import java.util.List;
-import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 /**
  * Created by leon on 5/25/17.
  */
-public class ArrayConversions {
-    public Stream<Person> getStream() {
-        return null;
+public final class ArrayConversion extends ConversionAgent {
+    private final Person[] people;
+
+    public ArrayConversion(Person... people) {
+        this.people = people;
     }
 
-    public static List<Person> getList() {
+    //TODO
+    public Stream<Person> toStream() {
         return null;
     }
 
-    public Stream<Person> filter(Predicate<? super Person> predicate) {
-        return getStream().filter(predicate);
+    @Override
+    public Person[] toArray() {
+        return this.people;
     }
 
+    //TODO
+    public List<Person> toList() {
+        return null;
+    }
 }

src/main/java/com/zipcodewilmington/lambdas/exercises/ConversionAgent.java

 package com.zipcodewilmington.lambdas.exercises;
 
+import com.zipcodewilmington.lambdas.anthropoid.Person;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
 /**
  * Created by leon on 5/25/17.
  */
-public class Conversion {
+public abstract class ConversionAgent {
+
+    abstract public List<Person> toList();
+
+    abstract public Stream<Person> toStream();
+
+    abstract public Person[] toArray();
+
+    public Stream<Person> filter(Predicate<? super Person> predicate) {
+        return toStream().filter(predicate);
+    }
 }

src/main/java/com/zipcodewilmington/lambdas/exercises/ListConversion.java

-package com.zipcodewilmington.lambdas;
+package com.zipcodewilmington.lambdas.exercises;
+
+import com.zipcodewilmington.lambdas.anthropoid.Person;
+
+import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Created by leon on 5/25/17.
  */
-public class ListConversions {
+public final class ListConversion extends ConversionAgent {
+    private final List<Person> people;
+
+    public ListConversion(List<Person> people) {
+        this.people = people;
+    }
+
+    @Override
+    public List<Person> toList() {
+        return this.people;
+    }
+
+    //TODO
+    public Stream<Person> toStream() {
+        return null;
+    }
+
+    //TODO
+    public Person[] toArray() {
+        return null;
+    }
 }

src/main/java/com/zipcodewilmington/lambdas/exercises/StreamConversion.java

 package com.zipcodewilmington.lambdas.exercises;
 
+import com.zipcodewilmington.lambdas.anthropoid.Person;
+
+import java.util.List;
+import java.util.stream.Stream;
+
 /**
  * Created by leon on 5/25/17.
  */
-public class StreamConversions {
+public final class StreamConversion extends ConversionAgent {
+    private final Stream<Person> people;
+
+    public StreamConversion(Stream<Person> people) {
+        this.people = people;
+    }
+
+    // TODO
+    public List<Person> toList() {
+        return null;
+    }
+
+    // TODO
+    public Stream<Person> toStream() {
+        return this.people;
+    }
+
+    // TODO
+    public Person[] toArray() {
+        return null;
+    }
 }

src/main/java/com/zipcodewilmington/lambdas/tools/RandomUtils.java

-package com.zipcode.tools;
+package com.zipcodewilmington.lambdas.tools;
 
 import java.awt.*;
 import java.util.*;
     private static final Random random = new Random();
 
     /** @return true with the likelihood of specified percentage */
-    public static boolean chance(float percentage) {
+    public static boolean createBoolean(float percentage) {
         return percentage > createFloat(0, 100);
     }
 
     }
 
     /** @return a random string of the specified length containing characters in the specified range */
-    public static String createString(char min, char max, int length) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < length; i++) {
+    public static String createString(char min, char max, int stringLength) {
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < stringLength; i++) {
             sb.append(createCharacter(min, max));
         }
         return sb.toString();
     }
 
+    /** @return an array of random string objects of the specified length containing characters in the specified range */
+    public static String[] createStrings(char min, char max, int stringLength, int stringCount) {
+        String[] strings = new String[stringCount];
+        for(int i=0;i<strings.length;i++) {
+            strings[i] = createString(min,max,stringLength);
+        }
+        return strings;
+    }
+
     /** @return a random date object ranging between the specified dates */
     public static Date createDate(int minYear, int maxYear) {
         GregorianCalendar gc = new GregorianCalendar();
 
     /** @return specified string value with random upper and lower casing assigned to each character */
     public static String shuffleCasing(String str) {
-        StringBuilder sb = new StringBuilder();
+        StringBuffer sb = new StringBuffer();
         for (String s : str.toLowerCase().split("")) {
-            sb.append(chance(50) ? s.toUpperCase() : s.toLowerCase());
+            sb.append(createBoolean(50) ? s.toUpperCase() : s.toLowerCase());
         }
         return sb.toString();
     }

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

 package com.zipcodewilmington.lambdas.tools;
 
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Iterator;
+
 /**
- * Created by leon on 5/24/17.
+ * Created by leon on 5/19/17.
  */
 public class ReflectionUtils {
+    public static HashMap<Field, String> getFieldMap(Object object) {
+        HashMap hm = new HashMap() {
+            @Override
+            public String toString() {
+                StringBuilder sb = new StringBuilder();
+                Iterator it = this.entrySet().iterator();
+
+                for (int i = 0; it.hasNext(); i++) {
+                    Entry pair = (Entry) it.next();
+                    sb
+                            .append("\n" + StringUtils.repeatString(150, "-"))
+                            .append(String.format("\nEntry number:\t\t%s", i))
+                            .append(String.format("\nKey:\t\t\t\t%s", pair.getKey()))
+                            .append(String.format("\nValue:\t\t\t\t%s", pair.getValue()));
+                    it.remove(); // prevents ConcurrentModificationException
+                }
+                return sb.toString();
+            }
+        };
+        for (Field f : object.getClass().getDeclaredFields()) {
+            try {
+                boolean defaultAccess = f.isAccessible();
+
+                // attempt to modify visibility
+                f.setAccessible(true);
+                hm.put(f, f.get(object).toString());
+                f.setAccessible(defaultAccess);
+            } catch (IllegalArgumentException | IllegalAccessException e) {
+                e.printStackTrace();
+                hm.put(f, null);
+            }
+
+        }
+        return hm;
+    }
 }

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

 package com.zipcodewilmington.lambdas.tools;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
 /**
  * Created by leon on 5/24/17.
  */
 public class StringUtils {
+    /**
+     * @param string - String to capitalize
+     * @return - input String with first character capitalized
+     */
+
+    public static String capitalizeFirstChar(String string) {
+        String firstChar = new Character(string.charAt(0)).toString();
+        return string.replaceFirst(firstChar, firstChar.toUpperCase());
+    }
+
+    /**
+     * @param numberOfRepeats - number of times to repeat this string
+     * @param val - value of string to repeat
+     * @return - `val` concatenated with itself `numberOfRepeats` times
+     */
+    public static String repeatString(int numberOfRepeats, String val) {
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < numberOfRepeats; i++) {
+            sb.append(val);
+        }
+        return sb.toString();
+    }
 }

src/test/java/com/zipcodewilmington/lambdas/TestPersonFactory.java

 package com.zipcodewilmington.lambdas;
 
+import com.zipcodewilmington.lambdas.tools.ReflectionUtils;
+import com.zipcodewilmington.lambdas.anthropoid.Person;
+import com.zipcodewilmington.lambdas.anthropoid.PersonFactory;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Stream;
+
 /**
  * Created by leon on 5/24/17.
  */
 public class TestPersonFactory {
+    int collectionSize = 1000;
+
+    @Test
+    public void testCreateRandomPersonList() {
+        checkStream(PersonFactory.createPersonList(collectionSize).stream());
+    }
+
+    @Test
+    public void testCreateRandomPersonArray() {
+        checkStream(Stream.of(PersonFactory.createPersonArray(collectionSize)));
+    }
+
+    @Test
+    public void testCreateRandomPersonStream() {
+        checkStream(PersonFactory.createPersonStream(collectionSize));
+    }
+
+    private void checkStream(Stream<Person> personStream) {
+        String messageCheckSize = "Ensuring appropriately sized stream was produced.";
+        String messageCheckKey = "Ensuring field is non-null";
+        String messageCheckValue = "Ensuring field-value is non-null";
+
+        Person[] personArray = personStream.toArray(Person[]::new);
+        Assert.assertEquals(messageCheckSize, collectionSize, personArray.length);
+        for (Person person : personArray) {
+            HashMap<Field, String> fieldMap = ReflectionUtils.getFieldMap(person);
+            for (Map.Entry<Field, String> entry : fieldMap.entrySet()) {
+                Field key = entry.getKey();
+                String value = entry.getValue();
+
+                Assert.assertTrue(messageCheckKey, key != null);
+                Assert.assertTrue(messageCheckValue, value != null);
+            }
+        }
+    }
 }

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

 /**
  * Created by leon on 5/2/17.
  */
-public class TestLambdaFilter {
-    private LambdaFilter lambdaFilter;
+public class TestStreamFilter {
+    private StreamFilter streamFilter;
 
     @Before
     public void setup() {
-        lambdaFilter = new LambdaFilter();
+        streamFilter = new StreamFilter();
     }
 
     @Test
     public void testToListMultiLine() {
-        testFilter(lambdaFilter.toListMultiLine());
+        testFilter(streamFilter.toListMultiLine());
     }
 
     @Test
     public void testToListOneLine() {
-        testFilter(lambdaFilter.toListOneLine());
+        testFilter(streamFilter.toListOneLine());
     }
 
     @Test
     public void testToArrayMultiLine() {
-        testFilter(lambdaFilter.toArrayMultiLine());
+        testFilter(streamFilter.toArrayMultiLine());
     }
 
     @Test
     public void testToArrayOneLine() {
-        testFilter(lambdaFilter.toArrayOneLine());
+        testFilter(streamFilter.toArrayOneLine());
     }
 
 
 
     private void testFilter(List<Person> persons) {
         for (Person p : persons) {
-            assert (p.name.getValue().startsWith(lambdaFilter.startingCharacter));
+            assert (p.name.getValue().startsWith(streamFilter.startingCharacter));
         }
     }
 }

src/test/java/com/zipcodewilmington/lambdas/TestStreamMap.java

 /**
  * Created by leon on 5/24/17.
  */
-public class
-TestMapSyntax {
+public class TestStreamMap {
     @Test
     public void test() {
 

src/test/java/com/zipcodewilmington/lambdas/TestSuiteFullRegression.java

 package com.zipcodewilmington.lambdas;
 
-/**
- * Created by leon on 5/24/17.
- */
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+
+@Suite.SuiteClasses({
+        TestStreamFilter.class,
+        TestStreamMap.class,
+        TestPersonFactory.class
+})
+
 public class TestSuiteFullRegression {
 }