Como ler arquivos em Kotlin: leitura de arquivos texto, CSV e manipulação com exemplos

O que é IO em Kotlin e como funciona a entrada/saída de arquivos 

Ao escrever um programa na linguagem de programação Kotlin, é comum precisarmos manipular arquivos, seja para ler, criar, abrir, salvar ou modificar arquivos de texto (.txt) ou arquivos CSV.  

Além de mostrar mensagens, também é possível receber informações dessa pessoa usuária ou interagir com arquivos, lendo e escrevendo dados conforme necessário. 

Essas operações são conhecidas no desenvolvimento de software como IO, Input/Output, ou entrada e saída. 

Como o IO funciona no Kotlin para leitura e escrita de arquivos 

Como o Kotlin roda na JVM, ele reutiliza toda a estrutura de IO da linguagem Java. Portanto, se você já tem experiência com Java, assim como vemos no curso de java.io, e suas bibliotecas de entrada e saída, pode aplicar as mesmas técnicas em Kotlin sem dificuldades. 

"Então, qual é a diferença no Kotlin?" 

A vantagem do Kotlin é tornar a manipulação de IO ainda mais prática, utilizando funções de extensão. 

Como ler arquivos em Java antes de usar o Kotlin File 

Temos várias opções ao ler um arquivo em Java, como, por exemplo, utilizando a classe Scanner: 

JAVA  
public class Leitor { 
public void ler() { 
     File arquivo = new File("lista-desejos.txt"); 
     try { 
         Scanner leitor = new Scanner(arquivo); 
         while(leitor.hasNext()){ 
                System.out.println(leitor.next()); 
         } 
            leitor.close(); 
     } catch (FileNotFoundException e) { 
            System.out.println("Falha ao ler o arquivo"); 
            e.printStackTrace(); 
     } 
} 
}

Neste código, para que a leitura seja feita, precisamos: 

• Acessar o arquivo via File; 
• Enviar o arquivo para o Scanner; 
• Pegar o conteúdo enquanto existe (e imprimir, por exemplo); 
• Fechar o recurso. 

Além de exigir o tratamento de exceções, esse código apresenta um certo "boilerplate" (código repetitivo) para tarefas simples. É possível simplificar esse processo usando o try-with-resources: 

JAVA  
File arquivo = new File("lista-desejos.txt"); 
try(Scanner leitor = new Scanner(arquivo);) { 
while(leitor.hasNext()){ 
        System.out.println(leitor.next()); 
} 
} catch (FileNotFoundException e) { 
    System.out.println("Falha ao ler o arquivo"); 
    e.printStackTrace(); 
}

A partir desta técnica, não há necessidade de fechar o recurso explicitamente, pois, ao usar essa instrução, qualquer referência que implemente Closeable, como é o caso da Scanner, tem o recurso fechado no final da instrução try. 

Note que, mesmo com as melhorias, ainda há diversas etapas para realizar uma leitura simples de arquivo em Java. 

Como ler arquivos de texto em Kotlin com funções de extensão 

No Kotlin, com as extensões para operações em arquivos, essa tarefa fica mais simples: é possível utilizar apenas uma chamada de função, como o forEachLine(): 

KOTLIN  
fun ler() { 
try { 
     File("lista-desejos.txt").forEachLine { linha -> 
            println(linha) 
     } 
} catch (e: FileNotFoundException) { 
        println("Falha ao ler o arquivo"); 
        e.printStackTrace(); 
} 
}

Podemos ainda simplificar utilizando a referência de método: 

KOTLIN  
fun ler() { 
try { 
     File("lista-desejos.txt").forEachLine(action = ::println) 
} catch (e: FileNotFoundException) { 
        println("Falha ao ler o arquivo"); 
        e.printStackTrace(); 
} 
}

À princípio parece mágica, mas internamente a estratégia é a mesma do try-catch-resources. 

Esse uso parece muito mais simples, mas internamente a estratégia utilizada é semelhante ao try-with-resources apresentado anteriormente. 

A implementação padrão de leitura utiliza um recurso que implementa a interface Closeable e garante o fechamento automático após a execução do forEachLine(). 

Como usar a função use() para leitura e manipulação de arquivos em Kotlin 

Além de usar as extensões de File, também podemos fazer o mesmo código que vimos com o try-catch-resources a partir da função use(), uma extensão de Closeable para usar um recurso e fechá-lo automaticamente após o uso: 

Além de usar as extensões de File, também podemos fazer o mesmo código que vimos com o try-with-resources a partir da função use(), uma extensão de Closeable para usar um recurso e fechá-lo automaticamente após o uso: 

KOTLIN  
fun ler() { 
    val arquivo = File("lista-desejos.txt") 
try { 
     Scanner(arquivo).use { leitor -> 
         while (leitor.hasNext()) { 
                println(leitor.next()) 
         } 
     } 
} catch (e: FileNotFoundException) { 
        println("Falha ao ler o arquivo") 
        e.printStackTrace() 
} 
}

Observação sobre charset: por padrão, forEachLine() e outras funções de leitura usam UTF-8 como charset. Se você precisar ler arquivos com outros encodings, pode especificar o charset como parâmetro: File("arquivo.txt").forEachLine(Charsets.ISO_8859_1) { linha -> ... } 

Além disso, se precisar salvar arquivos em Kotlin, criar e escrver arquivos txt, ou ler arquivos CSV em Kotlin, basta adaptar as funções mostradas ou usar bibliotecas que facilitem esse processo. 

Como aprender mais sobre o tema

Se você quer começar pela base da linguagem, a formação Linguagem Kotlin é a melhor porta de entrada. Se o seu foco for Android, a formação Desenvolva o seu primeiro App com Kotlin é uma ótima sequência.  

Para aprofundar, também vale olhar o curso Kotlin: evoluindo a aplicação com OO. E, se a ideia for usar Kotlin com back-end, a formação Kotlin e Spring Boot é bem indicada. Leia também: 

O que é Kotlin: linguagem, história e aplicações 

Criando e escrevendo arquivos em Kotlin 

Documentação oficial IO Java (Oracle) 

FAQ | Perguntas frequentes sobre leitura de arquivos em Kotlin 

Aqui estão as perguntas mais frequentes sobre leitura de arquivos em kotlin:

1. Por que ler arquivos em Kotlin é mais simples do que em Java?  

O Kotlin roda sobre a JVM e aproveita toda a estrutura de IO do Java, mas adiciona funções de extensão que reduzem o boilerplate. Com métodos como forEachLine(), você lê um arquivo texto em poucas linhas, sem precisar lidar manualmente com a abertura e o fechamento do recurso. 

2. Preciso fechar o arquivo manualmente depois de lê-lo em Kotlin?  

Não. Funções como forEachLine() e use() já implementam o fechamento automático do recurso, seguindo a mesma lógica do try-with-resources do Java. Isso evita vazamento de recursos e deixa o código mais limpo. 

3. Qual charset o Kotlin usa por padrão para ler arquivos de texto?  

Por padrão, funções como forEachLine() utilizam UTF-8. Caso o arquivo esteja em outro encoding, é possível especificar o charset como parâmetro, por exemplo File("arquivo.txt").forEachLine(Charsets.ISO_8859_1) { linha -> ... }. 

4. Quem já sabe Java precisa aprender tudo de novo para manipular arquivos em Kotlin?  

Não. Como o Kotlin reaproveita a biblioteca java.io, quem já conhece Java consegue aplicar o mesmo conhecimento sem dificuldades, apenas usando uma sintaxe mais enxuta. 

5. Esse mesmo processo serve para ler arquivos CSV em Kotlin? 

 Sim, a lógica é semelhante: as funções de extensão para arquivos texto também servem como base para leitura de CSV, bastando adaptar o tratamento de cada linha (por exemplo, separando os valores por vírgula).