Parsing Table Data in Kotlin

Welcome to the first lesson of our course on "Parsing Table Data in Kotlin". In this lesson, we will explore reading and processing table-like data from a text file using Kotlin. Understanding this skill is crucial for data analysis tasks, generating reports, and various applications that require structured data manipulation in software development. By the end of this lesson, you'll know how to parse a 2D table from a file and represent it using Kotlin collections and arrays.

Consider a file named students_marks.txt with the following content:

5 4 5 5
3 2 3 4
4 4 3 5
3 4 5 4

This file signifies a 2D table where each row denotes a student's scores across four subjects. In Kotlin, you can represent this data using a MutableList<IntArray> to store each row as an array of integers. Here's how you can define it:

// Define a MutableList to store integer arrays
val data: MutableList<IntArray> = mutableListOf()

To start, we utilize Path("students_marks.txt").readLines() to read all lines from the file. This function retrieves each line and stores it in a List<String>.

// Specify the input file path using a Path object
val filePath = Path("students_marks.txt")

// Read all lines from the text file
val lines: List<String> = filePath.readLines()

Here, filePath.readLines() opens and reads the file content into a list of strings, with each item representing a line from the file.

Now that we have the lines from the file stored in a List<String>, we'll convert these lines to a usable format, such as a list of integer arrays, by following these steps:

1. Split each line into tokens: Each line is a string with numbers separated by spaces. We'll split each line string into individual number strings using split(" ").

2. Convert tokens to integers: After splitting the strings, we'll convert each token into an integer using it.toInt(). This transforms the string representations of numbers into integers.

Let's transform each line to an array of integers and then compile these arrays into a list:

// Create a list to store the parsed integer arrays representing each row of data
val data = mutableListOf<IntArray>()

// Iterate over each line in the list of lines
for (line in lines) {
    // Split the trimmed line by spaces to get string tokens
    val tokens = line.trim().split(" ")
    // Create an integer array to store parsed numbers from tokens
    val nums = tokens.map { it.toInt() }.toIntArray()
    // Add the integer array representing the row of data to the list
    data.add(nums)
}

This code snippet iterates over each line, splits the line into tokens, converts each token to an integer, and stores it in an integer array, which is then added to a list.

In Kotlin, the students_marks.txt content is stored in a MutableList<IntArray>, representing the table as rows and columns:

• Row indices: Access rows using the list’s index, e.g., data[index].
• Column indices: Access columns within a row using the array index, e.g., data[rowIndex][columnIndex].

The data structure ensures each row corresponds to a line from the file, and each array element corresponds to a number in that line.

To validate our process, we will print the 2D list structure using Kotlin's standard printing mechanisms.

// Output the 2D array to verify the result
println("Parsed Table Data:")
data.forEach { row ->
    row.forEach { num ->
        print("$num ")
    }
    println()
}

This segment uses nested loops to iterate through each row and print each number in the row space-separated.

Expected Output:

Parsed Table Data:
5 4 5 5
3 2 3 4
4 4 3 5
3 4 5 4

Once we've successfully parsed the table data from the file into a MutableList<IntArray>, we can begin performing operations on this data for meaningful insights. For example, we can calculate the average mark for each student.

To calculate the average score, we will iterate through each student's scores in our parsed data and use Kotlin's average() method to compute it directly on the scores array:

// Iterate over each student's scores to calculate and print their average mark
data.forEachIndexed { index, scores ->
    // Calculate the average of the scores array
    val average = if (scores.isNotEmpty()) {
        scores.average()
    } else {
        0.0
    }
    // Print the average, formatted to two decimal places
    println("Student ${index + 1} Average: %.2f".format(average))
}

Explanation:

1. Iteration Over Data: We use forEachIndexed to iterate over each row of data, which allows us to access both the index and the scores (a student's marks).

2. Calculating the Average: We calculate the average directly within the loop using the average() method on the scores array. This handles any non-empty arrays by computing their average and defaults to 0.0 for empty arrays.

3. Printing Averages: For each student, the average is computed and formatted to two decimal places for clarity. The student's average is then printed along with their index (incremented by 1 for display purposes).

This approach provides us with the average scores per student based on the table data, making it straightforward to analyze and utilize student performance metrics.

In this lesson, we explored how to parse table data from a file using Kotlin. We utilized Path and readLines for file input and parsed data into a MutableList<IntArray> for convenient manipulation. Understanding file input handling and data representation in structured formats like lists and arrays is vital in many practical programming scenarios.

You're now ready to proceed to the practice exercises. These exercises will reinforce your new knowledge by encouraging you to apply similar techniques to other file formats and sizes, enhancing your skills in structured data manipulation in Kotlin. Enjoy the hands-on experience, and see you in the next lesson!