:)

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

@@ -2,30 +2,169 @@ package io.zipcoder;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class ItemParser {
+    private ArrayList<String> values;
+    private ArrayList<Item> itemList;
+    private int exceptionCount;
 
+    ItemParser(String rawList) {
+        this.values = parseRawDataIntoStringArray(rawList);
+        this.itemList = new ArrayList<Item>();
+        buildItemList();
+    }
 
-    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 {
+        LinkedHashMap<String, String> item = getKeyValueEntries(rawItem);
+        if (item.get(0) == null || item.get(1) == null) {
+            throw new ItemParseException();
+        }
+        Item newItem = new Item(fixAnyZeros(item.get(0)), Double.valueOf(item.get(1)), item.get(2), item.get(3));
+        return newItem;
+    }
+
+    public String fixAnyZeros(String s) {
+        Pattern pattern = Pattern.compile("[0]");
+        Matcher matcher = pattern.matcher(s);
+        return matcher.replaceAll("o");
+    }
+
+    public LinkedHashMap<String, String> getKeyValueEntries(String valuePair) {
+        ArrayList<String> keyValuePairs = findKeyValuePairsInRawItemData(valuePair);
+        LinkedHashMap<String, String> itemDescription = new LinkedHashMap<String, String>();
+        for (String keyValues : keyValuePairs) {
+            ArrayList<String> keyAndValue = splitKeysAndValue(keyValues);
+            itemDescription.put(convertToLowerCase(keyAndValue.get(0)), convertToLowerCase(keyAndValue.get(1)));
+        }
+        return itemDescription;
+    }
+
+    private String convertToLowerCase(String s) {
+        StringBuilder loweredString = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) >= 65 && s.charAt(i) <= 90) {
+                loweredString.append(s.charAt(i) + 32);
+            } else {
+                loweredString.append(s.charAt(i));
+            }
+        }
+        return loweredString.toString();
     }
 
-    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
+    public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem) {
         String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+        ArrayList<String> response = splitStringWithRegexPattern(stringPattern, rawItem);
+        return response;
+    }
+
+    public ArrayList<String> splitKeysAndValue(String rawItem) {
+        String keyValueSeparators = "[:|@|*|%]";
+        ArrayList<String> response = splitStringWithRegexPattern(keyValueSeparators, 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 void buildItemList() {
+        for (String itemDetails : values) {
+            try {
+                this.itemList.add(parseStringIntoItem(itemDetails));
+            } catch (ItemParseException e) {
+                incrementCounter();
+            }
+        }
+    }
 
+    private void incrementCounter() {
+        this.exceptionCount++;
+    }
+
+    public String getFormattedString() {
+        ArrayList<LinkedHashMap<String, Integer>> itemSeenInfo = new ArrayList<LinkedHashMap<String, Integer>>();
+        for (Item item : itemList) {
+            if (containsCheck(itemSeenInfo, item.getName()) == false) {
+                itemSeenInfo.add(getOccurrences(item.getName(), itemList));
+            }
+        }
+        StringBuilder output = new StringBuilder();
+
+        for (LinkedHashMap<String, Integer> item : itemSeenInfo) {
+            for (Map.Entry entry : item.entrySet()) {
+                if (checkIfName(entry.getKey())) {
+                    output.append(String.format("Name: %-10s \t\t\t " +
+                            "Seen: %5d\n================ \t\t\t " +
+                            "===========\n", entry.getKey(), entry.getValue()));
+                } else {
+                    output.append(String.format("Price: %-5s \t\t\t " +
+                            "Seen: %5d\n---------------- \t\t\t " +
+                            "-----------\n", entry.getKey(), entry.getValue()));
+                }
+            }
+        }
+        output.append("Errors          \t\t\t Seen: " + exceptionCount);
+        return output.toString();
+    }
+
+    private boolean checkIfName(Object key) {
+        Pattern numbers = Pattern.compile("\\d");
+        Matcher matcher = numbers.matcher(key.toString());
+        if (matcher.find() == true) {
+            return false;
+        }
+        return true;
+    }
+
+    private boolean containsCheck(ArrayList<LinkedHashMap<String, Integer>> itemSeenInfo, String targetItem) {
+        for (LinkedHashMap<String, Integer> item : itemSeenInfo) {
+            for (Map.Entry entry : item.entrySet()) {
+                if (entry.getKey().equals(targetItem)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public LinkedHashMap<String, Integer> getOccurrences(String name, ArrayList<Item> items) {
+        LinkedHashMap<String, Integer> itemOcc = new LinkedHashMap<String, Integer>();
+        ArrayList<Double> prices = new ArrayList<Double>();
+        int nameCount = 0;
+        for (Item item : items) {
+            if (item.getName().equals(name)) {
+                nameCount++;
+                prices.add(item.getPrice());
+            }
+        }
+        itemOcc.put(name, nameCount);
+        for (Double price : prices) {
+            if (!itemOcc.containsKey(price.toString())) {
+                int priceOcc = getPriceOccurrences(price, prices);
+                itemOcc.put(price.toString(), priceOcc);
+            }
+        }
+        return itemOcc;
+    }
+
+    public int getPriceOccurrences(Double targetPrice, ArrayList<Double> prices) {
+        int priceCount = 0;
+        for (Double price : prices) {
+            if (price == targetPrice) {
+                priceCount++;
+            }
+        }
+        return priceCount;
+    }
 
 }

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

@@ -13,7 +13,9 @@ public class Main {
 
     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.
+        ItemParser itemParser = new ItemParser(output);
+        String finalString = itemParser.getFormattedString();
+        System.out.println(finalString);
     }
 }

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

@@ -1,9 +1,11 @@
 package io.zipcoder;
 
+import org.apache.commons.io.IOUtils;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.io.IOException;
 import java.util.ArrayList;
 
 import static org.junit.Assert.*;
@@ -22,8 +24,10 @@ public class ItemParserTest {
     private ItemParser itemParser;
 
     @Before
-    public void setUp(){
-        itemParser = new ItemParser();
+    public void setUp() throws Exception {
+        ClassLoader classLoader = getClass().getClassLoader();
+        String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
+        itemParser = new ItemParser(result);
     }
 
     @Test