Writing Table Data to Text and CSV Files in Kotlin

Welcome to this lesson on writing table data to text files using Kotlin. In today's digital world, storing and sharing data efficiently is essential. Text files are a common means to achieve this due to their simplicity and compatibility with various systems. In this lesson, our goal is to learn how to write formatted table data into both text and CSV files using Kotlin. We will leverage Kotlin's standard library for file handling to achieve this task.

By the end of this lesson, you will be able to take a structured data format and write it to both text and CSV files using Kotlin. Let’s dive into this skill and build on what you've learned about parsing tables from text and CSV files.

Before we proceed, let's briefly recall two key concepts: Kotlin collections and basic file handling.

• Kotlin Collections: Kotlin provides the List<T> interface, which allows you to store a collection of items, such as rows in a table. This step is crucial as it helps organize your data into a structured format.

• File Handling: We have previously covered basic reading operations. Now, we will focus on writing data. Kotlin's standard library offers a straightforward API for path handling and output operations. Using classes such as Path for specifying file paths and bufferedWriter for efficient file writing, we can manage file output effectively.

These foundational concepts will guide us in the process of writing table data into a text file.

First, we'll define the Person data class, which will serve as the blueprint for our data entries. In this class, each Person object will have properties corresponding to the columns in our table:

data class Person(
    val name: String,
    val age: String,
    val occupation: String
)

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

val data = listOf(
    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 not only simplifies the process of adding or modifying rows but also facilitates the seamless writing of data to files.

To write data to a text file using tab delimiters in Kotlin, we need to utilize Kotlin's standard library functions for file handling. Here's how you can implement this:

First, we specify the file path using Path:

import kotlin.io.path.Path
import kotlin.io.path.bufferedWriter

// Define the path for the output text file
val outputTxtFilePath = Path("output.txt")

// Open a BufferedWriter to write to the file
outputTxtFilePath.bufferedWriter().use { writer ->
    // Write the header with tabs as delimiters
    writer.write("Name\tAge\tOccupation\n")
    
    // Iterate through each Person object
    data.forEach { person ->
        // Write the Person object as a tab-delimited line
        writer.write("${person.name}\t${person.age}\t${person.occupation}\n")
    }
}

println("Data successfully written to $outputTxtFilePath (tab-separated).")

In this code:

• The outputTxtFilePath is defined to specify where the file will be created and stored.
• We use bufferedWriter to efficiently handle buffered output to the specified file within a use block for automatic resource management.
• We write a header line, using tabs as delimiters.
• We loop through our list of Person objects, crafting each into a tab-separated format.
• Each formatted line is efficiently written to output.txt using the bufferedWriter.

In addition to writing to a text file with tab delimiters, you can manually write the data in CSV (Comma-Separated Values) format using Kotlin's standard library functions:

// Define the path for the output CSV file
val outputCsvFilePath = Path("output.csv")

// Open a BufferedWriter to write to the file
outputCsvFilePath.bufferedWriter().use { writer ->
    // Write the header with commas as delimiters
    writer.write("Name,Age,Occupation\n")
    
    // Iterate through each Person object
    data.forEach { person ->
        // Write the Person object as a comma-delimited line
        writer.write("${person.name},${person.age},${person.occupation}\n")
    }
}

println("Data successfully written to $outputCsvFilePath (comma-separated).")

In this code:

• outputCsvFilePath is specified similarly for the output CSV file.
• We open a bufferedWriter and process data following the same method used for the text file, except using commas as delimiters here.
• Each Person object is written line-by-line into the CSV format file located at the specified path.

In this lesson, you learned how to effectively structure, write, and verify data stored in text and CSV files using Kotlin. We started by preparing data using Lists and Kotlin's data class, then utilized Kotlin's file-handling techniques to write this data with tabs and commas as delimiters, respectively.

We encourage you to engage with the practice exercises that follow this lesson. Apply what you've learned to reinforce your understanding and gain confidence. Keep experimenting with different data structures, adapt them, and ensure your outputs meet your expectations. Well done on progressing through this important lesson.