methods written tests passed, working on formatting output

src/main/java/io/zipcoder/ItemParser.java

 package io.zipcoder;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static jdk.nashorn.internal.objects.NativeString.indexOf;
 
 public class ItemParser {
 
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ArrayList<String> parseRawDataIntoStringArray(String rawData) {
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawData);
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException {
+        ArrayList<String> values = getValues(toLowerCase(rawItem));
+
+        String name = values.get(0);
+        Double price = Double.valueOf(values.get(1));
+        String type = values.get(2);
+        String expiration = values.get(3);
+
+
+        return new Item(name, price, type, expiration);
+
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
+        String stringPattern = "[^a-zA-Z0-9\\:\\.\\/]+";
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
         return response;
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
+    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString) {
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
+    public String getValue(String input) throws ItemParseException {
+        ArrayList<String> kv = splitStringWithRegexPattern(":", input);
+        if (kv.size() < 2) {
+            throw new ItemParseException();
+        } else if (kv.size() == 2) {
+            return kv.get(1);
+        }
+        return null;
+    }
+
+    public ArrayList<String> getValues(String rawItem) throws ItemParseException {
 
+        ArrayList<String> KVPairs = findKeyValuePairsInRawItemData(rawItem);
+        ArrayList<String> values = new ArrayList<String>();
+
+        for (String pair : KVPairs) {
+            String value = getValue(pair);
+            if (value.equals("")) {
+                throw new ItemParseException();
+            } else {
+                values.add(value);
+            }
+        }
+        return values;
+    }
+
+    public String toLowerCase(String test) {
+        String[] lower = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
+        String[] upper = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
+
+        StringBuilder lowercase = new StringBuilder();
+
+        Pattern pattern = Pattern.compile(".");
+        Matcher matcher = pattern.matcher(test);
+
+
+        while (matcher.find()) {
+            String character = (matcher.group());
+            if (isUpper(character)) {
+                int i = indexOf(upper, character);
+                lowercase.append(lower[i]);
+            } else {
+                lowercase.append(character);
+            }
+        }
+        return lowercase.toString();
+    }
 
-}
+
+    public boolean isUpper(String c) {
+        Pattern pattern = Pattern.compile("[A-Z]");
+        Matcher matcher = pattern.matcher(c);
+        return matcher.find();
+    }
+
+    public int indexOf(String[] array, String c) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(c)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public int findNumberOfErrors(String input) {
+        ArrayList<String> rawData = parseRawDataIntoStringArray(input);
+        ArrayList<String> badFormat = new ArrayList<String>();
+
+        for (String data : rawData) {
+            try {
+                Item item = parseStringIntoItem(data);
+            } catch (ItemParseException e) {
+                badFormat.add(data);
+            }
+        }
+        return (badFormat.size());
+    }
+
+
+    public ArrayList<Item> findItems(String input) {
+        ArrayList<String> rawData = parseRawDataIntoStringArray(input);
+        ArrayList<Item> items = new ArrayList<Item>();
+
+        for (String data : rawData) {
+            try {
+                Item item = parseStringIntoItem(data);
+                items.add(item);
+            } catch (ItemParseException e) {
+                e.printStackTrace();
+            }
+        }
+        return items;
+    }
+
+    public Map<Object, Integer> getUniqueNames(ArrayList<Item> items, String methodname) {
+        try {
+            Map<Object, Integer> uniqueNames = new HashMap<>();
+
+            for (Item item : items) {
+                Class<?> e = item.getClass();
+                Method method = e.getMethod(methodname);
+                if (!uniqueNames.containsKey(method.invoke(item))) {
+
+                    uniqueNames.put(method.invoke(item), new Integer(1));
+                } else {
+                    int amount = uniqueNames.get(method.invoke(item));
+                    amount = amount + 1;
+                    uniqueNames.put(method.invoke(item), amount);
+                }
+            }
+            return uniqueNames;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}

src/main/java/io/zipcoder/Main.java

 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
 
 public class Main {
 
+    private static ItemParser itemParser = new ItemParser();
+
     public String readRawDataToString() throws Exception{
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
         return result;
     }
 
-    public static void main(String[] args) throws Exception{
+    public static void main(String[] args) throws Exception
+    {
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
-        // TODO: parse the data in output into items, and display to console.
-    }
-}
+
+        int errs = itemParser.findNumberOfErrors(output);
+        ArrayList<Item> items = itemParser.findItems(output);
+            }
+        }

src/test/java/io/zipcoder/ItemParserTest.java

 
 public class ItemParserTest {
 
-    private String rawSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawSingleItem = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
 
     private String rawSingleItemIrregularSeperatorSample = "naMe:MiLK;price:3.23;type:Food^expiration:1/11/2016##";
 
-    private String rawBrokenSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawBrokenSingleItem = "naMe:Milk;price:3.23;type;expiration:1/25/2016##";
 
     private String rawMultipleItems = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
-                                      +"naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
-                                      +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+            + "naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
+            + "NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
     private ItemParser itemParser;
 
     @Before
-    public void setUp(){
+    public void setUp() {
         itemParser = new ItemParser();
     }
 
     @Test
-    public void parseRawDataIntoStringArrayTest(){
+    public void parseRawDataIntoStringArrayTest() {
         Integer expectedArraySize = 3;
         ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
         Integer actualArraySize = items.size();
     }
 
     @Test
-    public void parseStringIntoItemTest() throws ItemParseException{
-        Item expected = new Item("milk", 3.23, "food","1/25/2016");
+    public void parseStringIntoItemTest() throws ItemParseException {
+        Item expected = new Item("milk", 3.23, "food", "1/25/2016");
         Item actual = itemParser.parseStringIntoItem(rawSingleItem);
         assertEquals(expected.toString(), actual.toString());
     }
 
     @Test(expected = ItemParseException.class)
-    public void parseBrokenStringIntoItemTest() throws ItemParseException{
+    public void parseBrokenStringIntoItemTest() throws ItemParseException {
         itemParser.parseStringIntoItem(rawBrokenSingleItem);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTest(){
+    public void findKeyValuePairsInRawItemDataTest() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
         assertEquals(expected, actual);
     }
 
     @Test
-    public void findKeyValuePairsInRawItemDataTestIrregular(){
+    public void findKeyValuePairsInRawItemDataTestIrregular() {
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItemIrregularSeperatorSample).size();
         assertEquals(expected, actual);
     }
+    @Test
+    public void toLowerCaseTest() {
+        String test = "MILK";
+        String expect = "milk";
+        String actual = itemParser.toLowerCase(test);
+        Assert.assertEquals(expect, actual);
+
+
+    }
+
+    @Test
+    public void isUpperTest() {
+        String test = "E";
+        Assert.assertTrue(itemParser.isUpper(test));
+    }
 }