In the Kotlin IO

Sguotao.top /Kotlin-2018…

IO stream is a very important part of Java, common data transfer, file upload and download are inseparable from it. So how does Kotlin’s IO compare to Java’s IO?

In Java IO

IO in Java can be divided into byte stream and character stream according to the way of processing data, and can be divided into input stream and output stream according to the different transmission direction. Let’s start with a Java IO framework.

In Java, we need to pay attention to the exception handling and the flow closing operation, otherwise it may cause memory overflow. For example, using BufferedReader to read the build.gradle file in your project directory.

public static void main(String[] args) {
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(new File("build.gradle")));
            String line;
            while((line = bufferedReader.readLine()) ! =null) { System.out.println(line); }}catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedReader.close();
            } catch(IOException e) { e.printStackTrace(); }}}Copy the code

In the Kotlin IO

Gradle file with BufferedReader, and then to summarize the IO in Kotlin.

fun main(args: Array<String>) {
    val file = File("build.gradle")
    val bufferedReader = BufferedReader(FileReader(file))
    var line: String

    try {
        while (true) { line = bufferedReader.readLine() ? :break
            println(line)
        }
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        try {
            bufferedReader.close()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}
Copy the code

This seems to be no different from Java writing, so where does Kotlin stand out? Fortunately, Kotlin encapsulates many higher-order functions. Here is a version that uses higher-order functions.

fun main(args: Array<String>) {
    val file = File("build.gradle")
    BufferedReader(FileReader(file)).use {
        var line: String
        while (true) { line = it.readLine() ? :break
            println(line)
        }
    }
}
Copy the code

The code has been streamlined, leaving out some exception catching, because such template code kotlin has already wrapped, so you don’t have to worry about forgetting to close the convection anymore. For small files, there is a simpler way to write:

fun main(args: Array<String>) {
    File("build.gradle").readLines().forEach(::println)
}
Copy the code

Kotlin extension function for IO

So what extension functions are available in Kotlin? What are the effects of these extension functions? Kotlin does not duplicate the IO streams that already exist in Java. Instead, Kotlin extends the byte streams and character streams that are often used. Here we can classify these extension functions into the following categories by differentiating extension objects.

BufferedReader (Charset: charset) is a bufferedReader whose extended object is an InputStream. Then we can call this method on InputStream and its subclasses, for example:

    val inputStream: InputStream = FileInputStream("build.gradle")
    inputStream.bufferedReader().forEachLine { line ->
        println(line)
    }
Copy the code

Kotlin’s extension of the byte stream

Kotlin’s extensions to the byte stream are mainly in byteStreamkt.class, as described below:

Kotlin’s extension to character streams

Kotlin’s extensions to character streams are mainly in TextStreamkt.class, and we’ll look at each of these extension functions one by one:

Kotlin’s extension to File

Kotlin’s extensions to File are mainly in filekt.class. Here are some of the extension functions:

Kotlin other IO extensions

IO streams in Java inherit the Closeable interface. In kotlin. IO, closeablekt. class, there is an extension function for use:

public inline fun 
        T.use(block: (T) -> R): R {
    var exception: Throwable? = null
    try {
        return block(this)}catch (e: Throwable) {
        exception = e
        throw e
    } finally {
        when {
            apiVersionIsAtLeast(1.1.0) - >this.closeFinally(exception)
            this= =null -> {}
            exception == null -> close()
            else ->
                try {
                    close()
                } catch (closeException: Throwable) {
                    // cause.addSuppressed(closeException) // ignored here}}}}Copy the code

The use function encapsulates the try… catch… Finally template code, which is why, in Kotlin, there is no convection shutdown when using use on IO streams, because Kotlin already encapsulates it.

In Kotlin. IO, consolekt. class encapsulates terminal IO operations such as system.out.print. In Kotlin, print and println can be directly printed on the command line.

Learning materials

1. Kotlin Bootcamp for Programmers
2. Kotlin Koans