works but counting too many errors at the moment and not enough items

pom.xml

     <groupId>io.zipcoder</groupId>
     <artifactId>PainfullAfternoon</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>

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

 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import static io.zipcoder.Main.count;
 
 public class ItemParser {
 
+    public ItemParser(){
+    }
 
     public ArrayList<String> parseRawDataIntoStringArray(String rawData){
         String stringPattern = "##";
     }
 
     public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+        List<String> list = findKeyValuePairsInRawItemData(rawItem);
+        Map<String, String> map = new HashMap<>();
+        for (String string : list){
+            Pattern keyPattern = Pattern.compile("([a-zA-Z0-9]+)(?=\\:)"); //(.+)(?=[\:])
+            Matcher keyMatch = keyPattern.matcher(string);
+            Pattern valPattern = Pattern.compile("(?<=[\\:])([^##]+)");
+            Matcher valMatch = valPattern.matcher(string);
+            if (keyMatch.find() && valMatch.find()) {
+                map.put(lower(keyMatch.group()), lower(valMatch.group()));
+            }
+        }
+        try {
+            return new Item(rmvZeros(map.get("name")), Double.parseDouble(map.get("price")), map.get("type"), map.get("expiration"));
+        } catch (NullPointerException n) {
+            throw new ItemParseException();
+        }
+//        Pattern p = Pattern.compile("[^a-zA-Z0-9\\:\\.\\/]");
+//        Matcher m = p.matcher(rawItem);
+//        String replaced = m.replaceAll("-");
+//        String otherPatter = "([a-zA-Z0-9\\/\\:\\.]+)(?=[^\\/])";
+
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
     }
 
     private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
-        return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
+        return new ArrayList<>(Arrays.asList(inputString.split(stringPattern)));
     }
 
 
+    private String lower(String input) {
+        StringBuilder inputLineT = new StringBuilder(input);
+        for (int i = 0; i < inputLineT.length(); i++) {
+            if (inputLineT.charAt(i) >= 65 && inputLineT.charAt(i) < 91 && i > 0) {
+                inputLineT.setCharAt(i, (char) (inputLineT.charAt(i) + 32));
+            }
+        }
+        return inputLineT.toString();
+    }
 
+    private String rmvZeros(String input) {
+        StringBuilder inputLineT = new StringBuilder(input);
+        for (int i = 0; i < inputLineT.length(); i++) {
+            if (inputLineT.charAt(i) == 48) {
+                inputLineT.setCharAt(i, 'o');
+            }
+        }
+        return inputLineT.toString();
+    }
 }

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

 
 import org.apache.commons.io.IOUtils;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 
 public class Main {
+    public static int count;
+    Map<String, List<Double>> map = new HashMap<>();
 
-    public String readRawDataToString() throws Exception{
+    private String readRawDataToString() throws Exception{
         ClassLoader classLoader = getClass().getClassLoader();
         String result = IOUtils.toString(classLoader.getResourceAsStream("RawData.txt"));
         return result;
     }
 
+    private void addToMap(Item item){
+        String key = item.getName();
+        List<Double> list = new ArrayList<>();
+
+        if (!map.containsKey(key)) {
+            list.add(item.getPrice());
+            map.put(key, list);
+        }
+        else {
+            list = map.get(key);
+            list.add(item.getPrice());
+            map.put(key, list);
+        }
+    }
+
+    private int getCount(List<Double> list, double d){
+        list.removeIf(e -> e != d);
+        return list.size();
+    }
+
+    public String writeOutput(){
+        StringBuilder sb = new StringBuilder();
+        for (String s : map.keySet()){
+            List<Double> l = map.get(s).stream().distinct().collect(Collectors.toList());
+            sb.append(String.format("%14s %8s %14s\n","name: " + s, " ", "seen: " + map.get(s).size()));
+            sb.append(String.format("%14s %8s %14s\n","==============", " ", "=============="));
+            for (Double d : l) {
+                sb.append(String.format("%14s %8s %14s\n","Price: " + d, " ", "seen: " + getCount(map.get(s),d)));
+                sb.append(String.format("%14s %8s %14s\n","--------------", " ", "--------------"));
+            }
+        }
+
+        sb.append("\n").append(count);
+        return sb.toString();
+    }
+
     public static void main(String[] args) throws Exception{
-        String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+        Main main = new Main();
+        String output = main.readRawDataToString();
+
+        ItemParser ip = new ItemParser();
+        List<String> list = ip.parseRawDataIntoStringArray(output);
+
+        for (String str : list) {
+            try {
+                Item newItem = ip.parseStringIntoItem(str);
+                main.addToMap(newItem);
+            } catch (ItemParseException e1) {
+                count++;
+            }
+        }
+
+        System.out.println(main.writeOutput());
+
         // TODO: parse the data in output into items, and display to console.
     }
 }

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

     public void findKeyValuePairsInRawItemDataTest(){
         Integer expected = 4;
         Integer actual = itemParser.findKeyValuePairsInRawItemData(rawSingleItem).size();
+        //System.out.println(itemParser.findKeyValuePairsInRawItemData(rawSingleItem));
         assertEquals(expected, actual);
     }