Welcome to the first lesson in our course on working with different files as data sources using Scala. In this lesson, we will explore JSON (JavaScript Object Notation), a popular data format. JSON is simple, lightweight, and easily readable, making it an excellent choice for exchanging data between applications.

JSON is widely used in web development for data exchange between a server and a web application, among other applications. Understanding JSON and how to parse it in Scala will enable you to work with vast amounts of data efficiently. Let's dive into JSON and see why it's an integral part of modern programming.

Before we parse JSON, let's understand its structure. JSON is built on two structures: a collection of key-value pairs (often referred to as an object) and an ordered list of values (an array). Each key-value pair consists of a string (the key) followed by a value, which can be a string, number, object, array, or boolean.

Here's our example JSON file, data.json:

JSON
Copy to clipboard
1{
2    "school": "Greenwood High",
3    "location": {
4        "city": "New York",
5        "state": "NY"
6    },
7    "students": [
8        {"name": "Emma", "age": 15, "grade": "10"},
9        {"name": "Liam", "age": 14, "grade": "9"},
10        {"name": "Olivia", "age": 16, "grade": "11"}
11    ]
12}

• Key-Value Pairs: Each entry in the JSON is a key-value pair, such as "school": "Greenwood High".
• Objects: Encapsulated with curly braces {}, containing key-value pairs. For example, the "location" object.
• Arrays: Defined with square brackets []. For instance, "students" is an array containing multiple student objects.

Understanding this structure is crucial when writing code to parse JSON.

First, we need to specify the path to our JSON file and read its content using Scala's os-lib.

Scala
Copy to clipboard
1// Path to the JSON file
2val filePath = os.pwd / "data.json"
3
4// Read the entire content of the JSON file into a string
5val data = os.read(filePath)

Here, we import the os library and declare a filePath variable that holds the path to our JSON file. Then, we use os.read to read the content of the file into a string variable data.

To work with JSON in Scala, many developers use the ujson library, part of the upickle ecosystem. ujson is lightweight, efficient, and straightforward, making it a popular choice for parsing JSON. It provides a simple API to read JSON strings and convert them into Scala structures.

Start by importing the library to access its parsing capabilities:

Scala
Copy to clipboard
1import ujson._

Next, use the ujson.read function, which reads the JSON string and converts it into a data structure that Scala can work with efficiently. This allows us to manipulate the JSON data within our Scala program:

Scala
Copy to clipboard
1// Parse the JSON string using ujson
2val parsedJson = ujson.read(data)

This process converts the entire JSON content into a Scala-readable object, which you can now work with in your program.

Finally, let's print out the parsed data to verify our parsing is successful using Scala's println.

Scala
Copy to clipboard
1// Output the parsed JSON data
2println(parsedJson)

This code will output the parsed JSON in a human-readable format, confirming the JSON is correctly loaded into the program.

Plain text
Copy to clipboard
1{"school":"Greenwood High","location":{"city":"New York","state":"NY"},"students":[{"name":"Emma","age":15,"grade":"10"},{"name":"Liam","age":14,"grade":"9"},{"name":"Olivia","age":16,"grade":"11"}]}

To display the parsed data in a more readable, formatted manner, we can use the ujson.write function with formatting options. The ujson.write function converts a parsed JSON object back into a string. By using the indent parameter, we can specify the number of spaces for indentation, which enhances the readability of the JSON data by structurally organizing it:

Scala
Copy to clipboard
1// Format the parsed JSON data with indentation for readability
2val formattedJson = ujson.write(parsedJson, indent = 4)
3
4// Output the formatted JSON data
5println(formattedJson)

This will produce a neatly formatted output, making it easier to read and visualize the hierarchical structure of the JSON data:

Plain text
Copy to clipboard
1{
2    "school": "Greenwood High",
3    "location": {
4        "city": "New York",
5        "state": "NY"
6    },
7    "students": [
8        {
9            "name": "Emma",
10            "age": 15,
11            "grade": "10"
12        },
13        {
14            "name": "Liam",
15            "age": 14,
16            "grade": "9"
17        },
18        {
19            "name": "Olivia",
20            "age": 16,
21            "grade": "11"
22        }
23    ]
24}

This formatted output is particularly useful for debugging and presenting data in a user-friendly manner.

In this lesson, we covered the essentials of JSON, understanding its structure and how to parse it using Scala. We explored JSON's components, walked through a real code example, and discussed practical insights into working with JSON data using the ujson library.

As you proceed to the practice exercises, focus on reinforcing your understanding of JSON's structure. This hands-on experience will prepare you for more advanced topics in subsequent lessons. Happy coding!