Writing Table Data to Files in Scala

Welcome to this lesson on writing table data to text files using Scala. In today's digital world, efficiently storing and sharing data is crucial. Text files offer a simple and compatible way to handle data across various systems. In this lesson, our goal is to learn how to write formatted table data into a text file using Scala, leveraging the power of the os-lib library for file operations.

By the end of this lesson, you will be equipped to take structured data and output it to a text file with Scala. Let’s explore this capability and build on what you've previously learned about parsing table and CSV files.

To start, we'll define a Person case class to serve as the blueprint for our data entries. In this case class, each Person object will have fields corresponding to the table's columns:

case class Person(name: String, age: String, occupation: String)

With this structure in place, we can create a list of Person objects. This list, data, acts as a collection of rows where each Person instance represents an individual record:

val data = List(
  Person("John", "28", "Engineer"),
  Person("Alice", "34", "Doctor"),
  Person("Bob", "23", "Artist")
)

In this example, we've added three Person objects to our list, each representing a row with fields for name, age, and occupation. This structured approach simplifies adding or modifying records and facilitates seamless data writing to files.

Now, let's write the data to a text file with tabs as delimiters using Scala's os-lib. Here's how we can accomplish this:

// Specify the output file path (text file)
val outputTxtFilePath = os.pwd / "output.txt"

// Prepare data for tab-separated TXT file
val txtContent = "Name\tAge\tOccupation\n" + data.map(p => s"${p.name}\t${p.age}\t${p.occupation}").mkString("\n") + "\n"

// Write the content to the TXT file
os.write.over(outputTxtFilePath, txtContent)

Below is the step-by-step explanation of the code used to write data to a text file in a tab-delimited format:

• Define the Output Path: The file path is set for output.txt.
• Prepare the Header and Data: The header Name\tAge\tOccupation is defined, followed by each Person's data being formatted into tab-separated lines.
• Write to File: os.write.over writes the content to output.txt, ensuring each entry is on its own line in the file.

In addition to a tab-delimited file, we can also write the data in CSV (Comma-Separated Values) format in Scala. Here's how to do this:

// Specify the output file path (csv file)
val outputCsvFilePath = os.pwd / "output.csv"

// Prepare data for comma-separated CSV file
val csvContent = "Name,Age,Occupation\n" + data.map(p => s"${p.name},${p.age},${p.occupation}").mkString("\n") + "\n"

// Write the content to the CSV file
os.write.over(outputCsvFilePath, csvContent)

Similarly, this code writes the csvContent to output.csv using a comma character as the delimiter, ensuring each record is placed on a new line.

After writing data to the text files, it’s essential to verify that the files contain the correct information. Here's how you can read and print both the tab-delimited and CSV files to ensure their accuracy:

// Read and print the contents of the tab-delimited TXT file
val txtFileContent = os.read(outputTxtFilePath)
println("Tab-delimited file content:")
println(txtFileContent)

// Read and print the contents of the CSV file
val csvFileContent = os.read(outputCsvFilePath)
println("CSV file content:")
println(csvFileContent)

This step is crucial for ensuring the integrity and accuracy of your file-writing operations. Here's the expected output:

Tab-delimited file content:
Name    Age  Occupation
John    28   Engineer
Alice   34   Doctor
Bob     23   Artist

CSV file content:
Name,Age,Occupation
John,28,Engineer
Alice,34,Doctor
Bob,23,Artist

The above output demonstrates the structure and format of the data as stored in each file, allowing you to confirm that the text and CSV files are correctly generated.

Here's how the complete code looks like, from defining the data structure to writing to files and verifying the written data:

import os._

case class Person(name: String, age: String, occupation: String)

@main def main() =
  val data = List(
    Person("John", "28", "Engineer"),
    Person("Alice", "34", "Doctor"),
    Person("Bob", "23", "Artist")
  )

  // Tab-delimited text file
  val outputTxtFilePath = os.pwd / "output.txt"
  val txtContent = "Name\tAge\tOccupation\n" + data.map(p => s"${p.name}\t${p.age}\t${p.occupation}").mkString("\n") + "\n"
  os.write.over(outputTxtFilePath, txtContent)

  // CSV file
  val outputCsvFilePath = os.pwd / "output.csv"
  val csvContent = "Name,Age,Occupation\n" + data.map(p => s"${p.name},${p.age},${p.occupation}").mkString("\n") + "\n"
  os.write.over(outputCsvFilePath, csvContent)

  // Verify written data
  val txtFileContent = os.read(outputTxtFilePath)
  println("Tab-delimited file content:")
  println(txtFileContent)

  val csvFileContent = os.read(outputCsvFilePath)
  println("CSV file content:")
  println(csvFileContent)

In this lesson, you've learned how to effectively structure, write, and verify data stored in a text file using Scala. We began by organizing data with a case class and a list and then utilized Scala's os-lib for file operations to output data using tabs and commas as delimiters.

Engage with the practice exercises following this lesson to reinforce your understanding. Experiment with different data structures, adapt them, and ensure your outputs meet expectations. Well done on advancing through this important lesson in Scala.