Check this post - https://www.baeldung.com/kotlin/csv-files - it contains a few nice references to some libraries or pure Kotlin approaches if you prefer to use those.

Applying it to your use case, maybe something like:

fun OutputStream.writeCsv(context: Context, listOfData: List<YourData>) {
    //get data create directory
   ......

    val writer = bufferedWriter()
    writer.write(""""Name", "Address", "Code"""")
    writer.newLine()
    listOfData.forEach {
        writer.write("${it.name}, ${it.address}, \"${it.code}\"")
        writer.newLine()
    }
    writer.flush()
    writer.close()
}

And then call this where you need it,

FileOutputStream("out777.cs").apply { writeCsv(listOfData) }

One thing to note here is using bufferedWriter:

FileWriter writes directly into Files and should be used only when the number of writes is less. BufferedWriter: BufferedWriter is almost similar to FileWriter but it uses internal buffer to write data into File. So if the number of write operations is more, the actual IO operations are less and performance is better.

Not tested but this might point you in a more cleaner and efficient solution. There are also some libraries specifically for this. Take a look

This can be achieved using basic Kotlin instead of an external library.

data class

data class Category(
    val id: String,
    val name: String,
)

utility function

fun <T> csvOf(
    headers: List<String>,
    data: List<T>,
    itemBuilder: (T) -> List<String>
) = buildString {
    append(headers.joinToString(",") { "\"$it\"" })
    append("\n")
    data.forEach { item ->
        append(itemBuilder(item).joinToString(",") { "\"$it\"" })
        append("\n")
    }
}

usage

fun main() {
    val firstCategory = Category(0, "Phone")
    val secondCategory = Category(1, "Laptop")
    val categories = listOf(firstCategory, secondCategory)
    val csv = csvOf(
        listOf("id", "name"),
        categories
    ) {
        listOf(it.id.toString(), it.name)
    }
    println(csv)
}

That tutorial on using Apache Commons for reading CSV is written with the assumption that you are writing for JVM, not Android. It's not simple to adapt it to Android. I don't think the Apache Commons library is necessary anyway, because CSV is such a simple text-based format.

Here are a couple of simple extension functions that can be called on a File to either read a CSV as a 2D List of Strings, or write a 2D List of Strings to a File. Think of the 2D list as a List of lines of data. Each value in the inner List is all the values in that line.

@Throws(IOException::class)
fun File.readAsCSV(): List<List<String>> {
    val splitLines = mutableListOf<List<String>>()
    forEachLine {
        splitLines += it.split(", ")
    }
    return splitLines
}

@Throws(IOException::class)
fun File.writeAsCSV(values: List<List<String>>) {
    val csv = values.joinToString("\n") { line -> line.joinToString(", ") }
    writeText(csv)
}

You should not do File IO operations on the main thread, because this freezes the UI and risks making your application crash with the Application Not Responding Error. It looks like you have some kind of game loop so I'm not sure how to apply this advice in your case.

Here are alternate versions of the above functions that use FileInputStream and FileOutputStream so they are more versatile on Android (since you can't get direct File access for some storage locations):

@Throws(IOException::class)
fun FileInputStream.readAsCSV() : List<List<String>> {
    val splitLines = mutableListOf<List<String>>()
    reader().buffered().forEachLine {
        splitLines += it.split(", ")
    }
    return splitLines
}

@Throws(IOException::class)
fun FileOutputStream.writeAsCSV(values: List<List<String>>) {
    val csv = values.joinToString("\n") { line -> line.joinToString(", ") }
    writer().buffered().use { it.write(csv) }
}

The given regex just works fine. Currently you try to split the string s at the raw regex as delimeter, which does not exists in s. Simply add .toRegex() to the regex.

val s = "John Doe, 13, \"Subject 1, Subject 2, Subject 3\""
var list: List<String> = s.split(",(?=([^\"]*\"[^\"]*\")*[^\"]*$)".toRegex())
Log.d("size:", list.size.toString() + " - subjects:" + list[2])

The simplest way to solve this is not to use reflection at all. You can pass the property values directly to the class constructor:

data class Member(val firstName: String, val lastName: String)

fun readCsvFileKotlin() {
    // ...
    for (line in reader) {
        val mbrProperties = line.split(",") 
        memberList.add(Member(mbrProperties[0], mbrProperties[1]))
    }
}

If you want to set properties through reflection, you need to declare them as var rather than val, so that they can be changed after the object is created. Then you can use the set method on the property object to change the property value:

data class Member(var firstName: String? = null, var lastName: String? = null)

fun readCsvFileKotlin() {
    // ...
    val prop = Member::firstName
    for (line in reader) { 
        val mbrProperties = line.split(",") 
        val member = Member()
        prop.set(member, mbrProperties[0])
        memberList.add(member)
    }
}

[Edit October 2019] A couple of months after I wrote this answer, Koyama Kenta wrote a Kotlin targeted library which can be found at https://github.com/doyaaaaaken/kotlin-csv and which looks much better to me than opencsv.

Example usage: (for more info see the github page mentioned)

import com.github.doyaaaaaken.kotlincsv.dsl.csvReader

fun main() {
    csvReader().open("src/main/resources/test.csv") {
        readAllAsSequence().forEach { row ->
            //Do something
            println(row) //[a, b, c]
        }
    }
}

For a complete minimal project with this example, see https://github.com/PHPirates/kotlin-csv-reader-example

Old answer using opencsv:

As suggested, it is convenient to use opencsv. Here is a somewhat minimal example:

// You can of course remove the .withCSVParser part if you use the default separator instead of ;
val csvReader = CSVReaderBuilder(FileReader("filename.csv"))
        .withCSVParser(CSVParserBuilder().withSeparator(';').build())
        .build()

// Maybe do something with the header if there is one
val header = csvReader.readNext()

// Read the rest
var line: Array<String>? = csvReader.readNext()
while (line != null) {
    // Do something with the data
    println(line[0])

    line = csvReader.readNext()
}

As seen in the docs when you do not need to process every line separately you can get the result in the form of a Map:

import com.opencsv.CSVReaderHeaderAware
import java.io.FileReader

fun main() {
    val reader = CSVReaderHeaderAware(FileReader("test.csv"))
    val resultList = mutableListOf<Map<String, String>>()
    var line = reader.readMap()
    while (line != null) {
        resultList.add(line)
        line = reader.readMap()
    }
    println(resultList)
    // Line 2, by column name
    println(resultList[1]["my column name"])
}

Dependency for Gradle: compile 'com.opencsv:opencsv:4.6' or for Gradle Kotlin DSL: compile("com.opencsv:opencsv:4.6") (as always, check for latest version in docs).