Info
In this guide we will parse an array list of hash maps into CSV, JSON and XML. The core concepts can be applied to parsing pretty much anything.CSV
Example for data in the CSV format:
1name,surname,age
2john,doe,45
3jan,doe,35
Tabular presentation:
| index | name | surname | age |
|---|---|---|---|
| 0 | john | doe | 45 |
| 1 | jan | doe | 35 |
Parsing values separated by comma is by far the easiest of the three encodings in this guide. Keep the separator in mind (here ,, but could be any of: ;, |, : or \t) and check for a header row.
To keep this guide simple we hard-code the header keys and will not parse them dynamically:
Decoding
To convert a data from CSV to Hash maps in a array list we will first read a file (data.csv) with the above content.
1import java.io.BufferedReader;
2import java.io.FileReader;
3import java.util.ArrayList;
4import java.util.HashMap;
5
6public class Main {
7 public static void main(String[] args) {
8 ArrayList<HashMap<String, String>> result = new ArrayList<>();
9 try{
10 // open the 'data.csv' file and create a reader
11 FileReader fileReader = new FileReader("data.csv");
12 // pass the reader to a buffered reader
13 BufferedReader bufferedReader = new BufferedReader(fileReader);
14
15 bufferedReader
16 // loop over the lines using the .lines() method
17 // which returns a stream
18 .lines()
19 // skip the header line
20 .skip(1)
21 // iterate over each line
22 .forEach(l -> {
23 // allocate a new hash map
24 HashMap<String, String> temp = new HashMap<>();
25
26 // split the line via its separator
27 String[] splitLine = l.split(",");
28 // assign the values to the know keys
29 temp.put("name", splitLine[0]);
30 temp.put("surname", splitLine[1]);
31 temp.put("age", splitLine[2]);
32
33 // add the hash map to the result list
34 result.add(temp);
35 });
36 } catch (Exception e){
37 // prints out if file cant be found or read
38 e.printStackTrace();
39 }
40
41 // print all hash maps in the list
42 result.forEach(System.out::println);
43 }
44}
Running the above yields the following result:
1{surname=doe, name=john, age=45}
2{surname=doe, name=jan, age=35}
Encoding
Encoding to csv is also very simple, instantiate a StringBuilder, append the header and after that append each line:
1import java.io.BufferedReader;
2import java.io.FileReader;
3import java.util.ArrayList;
4import java.util.HashMap;
5
6public class Main {
7 public static void main(String[] args) {
8 ArrayList<HashMap<String, String>> result = new ArrayList<>();
9 try{
10 // open the 'data.csv' file and create a reader
11 FileReader fileReader = new FileReader("data.csv");
12 // pass the reader to a buffered reader
13 BufferedReader bufferedReader = new BufferedReader(fileReader);
14
15 bufferedReader
16 // loop over the lines using the .lines() method
17 // which returns a stream
18 .lines()
19 // skip the header line
20 .skip(1)
21 // iterate over each line
22 .forEach(l -> {
23 // allocate a new hash map
24 HashMap<String, String> temp = new HashMap<>();
25
26 // split the line via its separator
27 String[] splitLine = l.split(",");
28 // assign the values to the know keys
29 temp.put("name", splitLine[0]);
30 temp.put("surname", splitLine[1]);
31 temp.put("age", splitLine[2]);
32
33 // add the hash map to the result list
34 result.add(temp);
35 });
36 } catch (Exception e){
37 // prints out if the csv is invalid or file cant be found / read
38 e.printStackTrace();
39 }
40
41 // print all hash maps in the list
42 result.forEach(System.out::println);
43
44 StringBuilder stringBuilder = new StringBuilder();
45
46 // append the header row + the line separator of the system
47 stringBuilder
48 .append("name,surname,age")
49 .append(System.lineSeparator());
50
51 // loop over each line
52 result.forEach(e -> {
53 // create the row by getting the values from the current hash map
54 String formattedRow = String.format("%s,%s,%s,%s",
55 e.get("name"),
56 e.get("surname"),
57 e.get("age"),
58 System.lineSeparator());
59 // add the new row to the string builder
60 stringBuilder.append(formattedRow);
61 });
62
63 System.out.println(stringBuilder);
64 }
65}
Running the above yields the following result:
1{surname=doe, name=john, age=45}
2{surname=doe, name=jan, age=35}
3name,surname,age
4john,doe,45
5jan,doe,35
As expected, first the two decoded rows, afterwards the encoded representation as csv with the header row.
XML
XML is a somewhat outdated data exchange format, but especially people around java use it for configurations and data storage. The format is a lot more verbose, especially compared to csv.
Example for data in the XML format:
1<?xml version="1.0" encoding="UTF-8"?>
2<root>
3 <person>
4 <name>John</name>
5 <surname>Doe</surname>
6 <age>45</age>
7 </person>
8 <person>
9 <name>Jan</name>
10 <surname>Doe</surname>
11 <age>35</age>
12 </person>
13</root>
Decoding
Parsing XML requires a lot of boilerplate in Java so be prepared. I copied the above XML to a data.xml file.
1import org.w3c.dom.Document;
2import org.w3c.dom.Element;
3import org.w3c.dom.Node;
4import org.w3c.dom.NodeList;
5
6import javax.xml.parsers.DocumentBuilder;
7import javax.xml.parsers.DocumentBuilderFactory;
8import java.util.ArrayList;
9import java.util.HashMap;
10
11public class Main {
12 public static void main(String[] args) {
13 // result list which contains all parsed rows
14 ArrayList<HashMap<String, String>> result = new ArrayList<>();
15 try {
16 // create a factory
17 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
18 // use the above factory to get a document builder
19 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
20 // use the document builder to parse the xml in the file 'data.xml'
21 Document doc = documentBuilder.parse("data.xml");
22
23 // get the list of persons
24 NodeList personList = doc.getElementsByTagName("person");
25 // loop over the list of person
26 for (int i = 0; i < personList.getLength(); i++) {
27 // create a node out of the current item
28 Node item = personList.item(i);
29 // check if the node is an Element
30 if (item.getNodeType() == Node.ELEMENT_NODE) {
31 // new hash map to contain the values of the row
32 HashMap<String, String> temp = new HashMap<>();
33 // put all values for the keys into the above map
34 temp.put("name", ((Element) item)
35 .getElementsByTagName("name")
36 .item(0)
37 .getTextContent());
38
39 temp.put("surname", ((Element) item)
40 .getElementsByTagName("surname")
41 .item(0)
42 .getTextContent());
43
44 temp.put("age", ((Element) item)
45 .getElementsByTagName("age")
46 .item(0)
47 .getTextContent());
48
49 // add the row to the result list
50 result.add(tmap);
51 }
52 }
53 } catch (Exception e) {
54 // triggers if xml is invalid or the file cant be opened
55 e.printStackTrace();
56 }
57 // print the list
58 result.forEach(System.out::println);
59 }
60}
Running the above yields the following result:
1{surname=Doe, name=John, age=45}
2{surname=Doe, name=Jan, age=35}
Encoding
Converting the parsed data back into XML requires even more boilerplate so read the comments carefully:
1import org.w3c.dom.Document;
2import org.w3c.dom.Element;
3import org.w3c.dom.Node;
4import org.w3c.dom.NodeList;
5
6import javax.xml.parsers.DocumentBuilder;
7import javax.xml.parsers.DocumentBuilderFactory;
8import javax.xml.transform.OutputKeys;
9import javax.xml.transform.Transformer;
10import javax.xml.transform.TransformerFactory;
11import javax.xml.transform.dom.DOMSource;
12import javax.xml.transform.stream.StreamResult;
13import java.io.StringWriter;
14import java.util.ArrayList;
15import java.util.HashMap;
16
17public class XML {
18 public static void main(String[] args) {
19 // result list which contains all parsed rows
20 ArrayList<HashMap<String, String>> result = new ArrayList<>();
21 try {
22 // create a factory
23 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
24 // use the above factory to get a document builder
25 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
26 // use the document builder to parse the xml in the file 'data.xml'
27 Document doc = documentBuilder.parse("data.xml");
28
29 // get the list of persons
30 NodeList personList = doc.getElementsByTagName("person");
31 // loop over the list of person
32 for (int i = 0; i < personList.getLength(); i++) {
33 // create a node out of the current item
34 Node item = personList.item(i);
35 // check if the node is an Element
36 if (item.getNodeType() == Node.ELEMENT_NODE) {
37 // new hash map to contain the values of the row
38 HashMap<String, String> temp = new HashMap<>();
39 // put all values for the keys into the above map
40 temp.put("name", ((Element) item)
41 .getElementsByTagName("name")
42 .item(0)
43 .getTextContent());
44
45 temp.put("surname", ((Element) item)
46 .getElementsByTagName("surname")
47 .item(0)
48 .getTextContent());
49
50 temp.put("age", ((Element) item)
51 .getElementsByTagName("age")
52 .item(0)
53 .getTextContent());
54
55 // add the row to the result list
56 result.add(tmap);
57 }
58 }
59 } catch (Exception e) {
60 // triggers if xml is invalid or the file cant be opened
61 e.printStackTrace();
62 }
63 // print the list
64 result.forEach(System.out::println);
65
66 try {
67 // create a factory
68 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
69 // use the factory to get a new document builder
70 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
71
72 // use the document builder to get a new document
73 Document doc = documentBuilder.newDocument();
74
75 // create the root element
76 Element rootElement = doc.createElement("root");
77 // append the root element to the document
78 doc.appendChild(rootElement);
79
80 // loop over the maps in the result list
81 for (HashMap<String, String> map : result) {
82 // create a person element
83 Element person = doc.createElement("person");
84 // add the person element to the root element
85 rootElement.appendChild(person);
86
87 // create elements and set their text content
88 // to the value stored in the hash map
89 Element name = doc.createElement("name");
90 name.setTextContent(map.get("name"));
91 person.appendChild(name);
92
93 Element surname = doc.createElement("surname");
94 surname.setTextContent(map.get("surname"));
95 person.appendChild(surname);
96
97 Element age = doc.createElement("age");
98 age.setTextContent(map.get("age"));
99 person.appendChild(age);
100 }
101
102 // get a new transformer factory
103 TransformerFactory transformerFactory = TransformerFactory.newInstance();
104 // use the factory to get a new Transformer
105 Transformer transformer = transformerFactory.newTransformer();
106
107 // instruct the transformer
108 // to add XML declaration at the top of the file
109 transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
110 // instruct the transformer to indent the output
111 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
112
113 // get a new DOMSource from the document
114 DOMSource source = new DOMSource(doc);
115 // create a stringwriter to transform the source into
116 StringWriter stringWriter = new StringWriter();
117 transformer.transform(source, new StreamResult(stringWriter));
118
119 // print the output
120 System.out.println(stringWriter);
121 } catch (Exception e) {
122 e.printStackTrace();
123 }
124 }
125}
Running the above yields the following result:
1{surname=Doe, name=John, age=45}
2{surname=Doe, name=Jan, age=35}
3<root>
4 <person>
5 <name>John</name>
6 <surname>Doe</surname>
7 <age>45</age>
8 </person>
9 <person>
10 <name>Jan</name>
11 <surname>Doe</surname>
12 <age>35</age>
13 </person>
14</root>
JSON
Json is the de facto standard data exchange and configuration standard. The whole JavaScript and Typescript ecosystem uses JSON to configure tools and send + receive data from REST APIS.
Danger
To parse json we us the org.json library. I wont discuss package / library managment in depth here, but the repo includes a guide for adding the library to your project.
Adding org.json to your project using gradle:
- Add the following highlighted line to your
build.gradle:
1plugins {
2 id 'java'
3}
4
5group 'org.example'
6version null
7
8repositories {
9 mavenCentral()
10}
11
12dependencies {
13 implementation group: 'org.json', name: 'json', version: '20211205'
14}
- Click on the green arrow next to the
dependenciesto download the dependency
Decoding
The example we want to parse into an ArrayList of hash maps is the following:
1[
2 {
3 "name": "John",
4 "surname": "Doe",
5 "age": 45
6 },
7 {
8 "name": "Jan",
9 "surname": "Doe",
10 "age": 35
11 }
12]
Parsing a string to json is fairly easy while using the org.json library:
1import java.io.BufferedReader;
2import java.io.File;
3import java.io.FileReader;
4import java.util.ArrayList;
5import java.util.HashMap;
6import java.util.stream.Collectors;
7
8import org.json.*;
9
10public class Main {
11 public static void main(String[] args) {
12 ArrayList<HashMap<String, String>> result = new ArrayList<>();
13 try{
14 // create a new file
15 File file = new File("data.json");
16 FileReader fileReader = new FileReader(file);
17 // read file with bufferedReader for better perf
18 BufferedReader bufferedReader = new BufferedReader(fileReader);
19 // read the lines and join them by "\n"
20 String fileContent = bufferedReader.lines().collect(Collectors.joining("\n"));
21
22 // use org.json.JSONArray to parse the string to a json object
23 JSONArray jsonArray = new JSONArray(fileContent);
24 // loop over every object in the array
25 for(int i = 0; i < jsonArray.length(); i++){
26 // create a new json object for every entry in the array
27 JSONObject o = jsonArray.getJSONObject(i);
28
29 // hash map to store row values
30 HashMap<String, String> temp = new HashMap<>();
31 // add values to keys
32 temp.put("name", o.getString("name"));
33 temp.put("surname", o.getString("surname"));
34 temp.put("age", String.valueOf(o.getInt("age")));
35
36 // add row to result
37 result.add(temp);
38 }
39 } catch (Exception e){
40 e.printStackTrace();
41 }
42
43 result.forEach(System.out::println);
44 }
45}
The above results in the same output as the parsing for CSV and XML:
1{surname=Doe, name=John, age=45}
2{surname=Doe, name=Jan, age=35}
Encoding
Encoding java objects into json is so easy it can be done in one loc:
1import java.io.BufferedReader;
2import java.io.File;
3import java.io.FileReader;
4import java.util.ArrayList;
5import java.util.HashMap;
6import java.util.stream.Collectors;
7
8import org.json.*;
9
10public class Main {
11 public static void main(String[] args) {
12 ArrayList<HashMap<String, String>> result = new ArrayList<>();
13 try{
14 // create a new file
15 File file = new File("data.json");
16 FileReader fileReader = new FileReader(file);
17 // read file with bufferedReader for better perf
18 BufferedReader bufferedReader = new BufferedReader(fileReader);
19 // read the lines and join them by "\n"
20 String fileContent = bufferedReader
21 .lines()
22 .collect(Collectors.joining("\n"));
23
24 // use org.json.JSONArray to parse the string to a json object
25 JSONArray jsonArray = new JSONArray(fileContent);
26 // loop over every object in the array
27 for(int i = 0; i < jsonArray.length(); i++){
28 // create a new json object for every entry in the array
29 JSONObject o = jsonArray.getJSONObject(i);
30
31 // hash map to store row values
32 HashMap<String, String> temp = new HashMap<>();
33 // add values to keys
34 temp.put("name", o.getString("name"));
35 temp.put("surname", o.getString("surname"));
36 temp.put("age", String.valueOf(o.getInt("age")));
37
38 // add row to result
39 result.add(temp);
40 }
41 } catch (Exception e){
42 e.printStackTrace();
43 }
44
45 result.forEach(System.out::println);
46
47 System.out.println(new JSONArray(result).toString(4));
48 }
49}
The above results in:
1{surname=Doe, name=John, age=45}
2{surname=Doe, name=Jan, age=35}
3[
4 {
5 "name": "John",
6 "surname": "Doe",
7 "age": "45"
8 },
9 {
10 "name": "Jan",
11 "surname": "Doe",
12 "age": "35"
13 }
14]