Ensinando Java: Leitura/Escrita em Arquivos e Acesso ao PostgreSQL

Tópicos

Java Leitura e Escrita em Arquivos
Exemplos: TXT, CSV e JSON
Atividade Prática de Arquivos
Java Acesso a Bancos de Dados PostgreSQL
Operações DDL no PostgreSQL
Operações CRUD no PostgreSQL
Exemplo de Sistema CRUD
Atividades Práticas de Banco de Dados

Java Leitura e Escrita em Arquivos

Introdução ao File I/O em Java

File Input/Output (I/O) é fundamental para interagir com o sistema de arquivos.
Permite que programas Java leiam dados de arquivos e escrevam dados em arquivos.
Java fornece diversas classes e APIs para manipular arquivos.

API de I/O do Java

A API de I/O do Java está principalmente no pacote java.io.
Duas categorias principais de streams:
- Byte Streams: Usados para ler e escrever dados brutos (bytes). Classes como InputStream e OutputStream.
- Character Streams: Usados para ler e escrever dados de caracteres (texto). Classes como Reader e Writer.
Classes importantes para manipulação de arquivos:
- File: Representa um arquivo ou diretório no sistema de arquivos.
- FileReader: Reader para ler arquivos de texto.
- FileWriter: Writer para escrever em arquivos de texto.
- BufferedReader: Reader que armazena em buffer caracteres, proporcionando leitura eficiente.
- BufferedWriter: Writer que armazena em buffer caracteres, proporcionando escrita eficiente.

Leitura de Arquivos TXT

Utilize as classes FileReader e BufferedReader para ler arquivos de texto linha por linha.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LerTXT {
    public static void main(String[] args) {
        String nomeArquivo = "exemplo.txt";
        try (BufferedReader br = new BufferedReader(new FileReader(nomeArquivo))) {
            String linha;
            while ((linha = br.readLine()) != null) {
                System.out.println(linha);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Escrita em Arquivos TXT

Utilize as classes FileWriter e BufferedWriter para escrever texto em arquivos.

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class EscreverTXT {
    public static void main(String[] args) {
        String nomeArquivo = "saida.txt";
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(nomeArquivo))) {
            bw.write("Esta é a primeira linha.");
            bw.newLine();
            bw.write("Esta é a segunda linha.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Leitura de Arquivos CSV

CSV (Comma Separated Values) é um formato comum para dados tabulares.
Uma maneira simples de ler é usar BufferedReader e dividir cada linha pela vírgula.
Para um tratamento mais robusto (lidar com aspas, separadores diferentes), bibliotecas como Apache Commons CSV são recomendadas.

Leitura de Arquivos CSV (Simples)

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LerCSVSimples {
    public static void main(String[] args) {
        String nomeArquivo = "dados.csv";
        try (BufferedReader br = new BufferedReader(new FileReader(nomeArquivo))) {
            String linha;
            while ((linha = br.readLine()) != null) {
                String[] campos = linha.split(",");
                System.out.println("Nome: " + campos[0] + ", Idade: " + campos[1]);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Leitura de Arquivos CSV (Apache Commons CSV)

Dependência (Maven):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-csv</artifactId>
    <version>1.10.0</version>
</dependency>

Esta biblioteca facilita o parsing de arquivos CSV.

Leitura de Arquivos CSV (Apache Commons CSV) - Exemplo

import org.apache.commons.csv.*;
import java.io.*;

public class LerCSVCommons {
    public static void main(String[] args) throws IOException {
        try (Reader in = new FileReader("dados.csv")) {
            Iterable<CSVRecord> records = CSVFormat.DEFAULT.withHeader("Nome", "Idade").parse(in);
            for (CSVRecord record : records) {
                String nome = record.get("Nome");
                String idade = record.get("Idade");
                System.out.println("Nome: " + nome + ", Idade: " + idade);
            }
        }
    }
}

Escrita em Arquivos CSV

Similar à leitura, você pode usar BufferedWriter e formatar as linhas com vírgulas.
Apache Commons CSV também oferece funcionalidades para escrita.

Escrita em Arquivos CSV (Simples)

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class EscreverCSVSimples {
    public static void main(String[] args) {
        String nomeArquivo = "saida.csv";
        String[][] dados = {{"João", "30"}, {"Maria", "25"}};
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(nomeArquivo))) {
            for (String[] linha : dados) {
                bw.write(String.join(",", linha));
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Escrita em Arquivos CSV (Apache Commons CSV) - Exemplo

import org.apache.commons.csv.*;
import java.io.*;

public class EscreverCSVCommons {
    public static void main(String[] args) throws IOException {
        try (FileWriter out = new FileWriter("saida.csv")) {
            try (CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT.withHeader("Nome", "Idade"))) {
                printer.printRecord("Carlos", 35);
                printer.printRecord("Ana", 28);
            }
        }
    }
}

Leitura de Arquivos JSON

JSON (JavaScript Object Notation) é um formato popular para troca de dados.
Java não possui uma API nativa completa para JSON. Bibliotecas como Jackson ou Gson são comumente usadas.
Dependência Jackson (Maven):

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.17.0</version>
</dependency>

Dependência Gson (Maven):

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

Leitura de Arquivos JSON (Jackson) - Exemplo

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;

public class LerJSONJackson {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            JsonNode rootNode = mapper.readTree(new File("dados.json"));
            String nome = rootNode.get("nome").asText();
            int idade = rootNode.get("idade").asInt();
            System.out.println("Nome: " + nome + ", Idade: " + idade);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Escrita em Arquivos JSON (Jackson) - Exemplo

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class EscreverJSONJackson {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
            Map<String, Object> data = new HashMap<>();
            data.put("nome", "Carlos");
            data.put("idade", 35);
            mapper.writeValue(new File("saida.json"), data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Atividade Prática: Leitura e Escrita de Arquivos

Crie um programa Java que:
1. Leia um arquivo TXT chamado entrada.txt, onde cada linha contém o nome de uma pessoa.
2. Crie um novo arquivo CSV chamado nomes.csv com duas colunas: "Nome" e "Tamanho".
3. Para cada nome lido do arquivo TXT, escreva no arquivo CSV o nome e o tamanho da string do nome.
4. Leia o arquivo nomes.csv e imprima no console cada linha.

Java Acesso a Bancos de Dados PostgreSQL

Acesso a Bancos de Dados com JDBC

JDBC (Java Database Connectivity) é uma API Java para interagir com bancos de dados.
Para conectar ao PostgreSQL, precisamos do driver JDBC específico.
Dependência PostgreSQL JDBC (Maven):

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.7.2</version>
</dependency>

Conectando ao PostgreSQL com JDBC

Utilize a classe DriverManager para obter uma conexão.
A URL de conexão para PostgreSQL geralmente segue o formato: jdbc:postgresql://host:port/database.
Você precisará do nome de usuário e senha para autenticação.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConectarPostgreSQL {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha)) {
            System.out.println("Conexão bem-sucedida!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Operações no Banco de Dados PostgreSQL

Operações DDL (Data Definition Language)

DDL são comandos para definir a estrutura do banco de dados.
Inclui operações como criar, alterar e excluir bancos de dados e tabelas.

Create Database

Cria um novo banco de dados no servidor PostgreSQL.
Comando SQL: CREATE DATABASE nome_do_banco;.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class CriarBanco {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/"; // Conectar sem especificar o banco
        String usuario = "postgres"; // Usuário padrão
        String senha = "suasenha";
        String nomeBanco = "novobanco";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "CREATE DATABASE " + nomeBanco;
            statement.executeUpdate(sql);
            System.out.println("Banco de dados '" + nomeBanco + "' criado com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Drop Database

Remove um banco de dados existente do servidor PostgreSQL.
Comando SQL: DROP DATABASE nome_do_banco;.
Cuidado: Esta operação é irreversível e apaga todos os dados.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class ExcluirBanco {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/";
        String usuario = "postgres";
        String senha = "suasenha";
        String nomeBanco = "novobanco";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "DROP DATABASE IF EXISTS " + nomeBanco; // IF EXISTS evita erros se o banco não existir
            statement.executeUpdate(sql);
            System.out.println("Banco de dados '" + nomeBanco + "' excluído com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Use Database

Seleciona o banco de dados que será utilizado para as operações subsequentes.
Em JDBC, o banco de dados é geralmente especificado na URL de conexão.
Exemplo de URL: jdbc:postgresql://localhost:5432/nome_do_banco.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class UsarBanco {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha)) {
            System.out.println("Conectado ao banco de dados 'meubanco'.");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Create Table

Cria uma nova tabela dentro do banco de dados selecionado.
Comando SQL: CREATE TABLE nome_da_tabela (coluna1 tipo restrições, coluna2 tipo restrições, ...);.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class CriarTabela {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "CREATE TABLE pessoas (" +
                         "id SERIAL PRIMARY KEY," +
                         "nome VARCHAR(50) NOT NULL," +
                         "idade INTEGER" +
                         ");";
            statement.executeUpdate(sql);
            System.out.println("Tabela 'pessoas' criada com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Drop Table

Remove uma tabela existente do banco de dados.
Comando SQL: DROP TABLE nome_da_tabela;.
Cuidado: Apaga todos os dados da tabela.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class ExcluirTabela {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        String nomeTabela = "pessoas";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "DROP TABLE IF EXISTS " + nomeTabela;
            statement.executeUpdate(sql);
            System.out.println("Tabela '" + nomeTabela + "' excluída com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Truncate Table

Remove todos os dados de uma tabela, mas mantém a estrutura da tabela.
Comando SQL: TRUNCATE TABLE nome_da_tabela;.
Mais rápido que DELETE FROM tabela; para remover todos os registros.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class TruncarTabela {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        String nomeTabela = "pessoas";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "TRUNCATE TABLE " + nomeTabela;
            statement.executeUpdate(sql);
            System.out.println("Tabela '" + nomeTabela + "' truncada com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Alter Table

Modifica a estrutura de uma tabela existente (adicionar, remover, alterar colunas, etc.).
Comando SQL: ALTER TABLE nome_da_tabela operação;.
Exemplos de operações: ADD COLUMN, DROP COLUMN, ALTER COLUMN.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class AlterarTabela {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        String nomeTabela = "pessoas";
        String nomeColuna = "email";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement()) {
            String sql = "ALTER TABLE " + nomeTabela + " ADD COLUMN " + nomeColuna + " VARCHAR(100);";
            statement.executeUpdate(sql);
            System.out.println("Coluna '" + nomeColuna + "' adicionada à tabela '" + nomeTabela + "' com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Operações CRUD (Create, Read, Update, Delete)

CRUD são as quatro operações básicas para manipular dados em um banco de dados.
Create (Criar): Adicionar novos registros à tabela.
Read (Ler): Recuperar registros da tabela.
Update (Atualizar): Modificar registros existentes na tabela.
Delete (Excluir): Remover registros da tabela.

Create (Insert)

Adiciona um novo registro à tabela.
Comando SQL: INSERT INTO nome_da_tabela (coluna1, coluna2, ...) VALUES (valor1, valor2, ...);.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class InserirPessoa {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        String nome = "Ricardo";
        int idade = 40;

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             PreparedStatement pstmt = conexao.prepareStatement("INSERT INTO pessoas (nome, idade) VALUES (?, ?)")) {
            pstmt.setString(1, nome);
            pstmt.setInt(2, idade);
            int linhasAfetadas = pstmt.executeUpdate();
            System.out.println(linhasAfetadas + " linha(s) inserida(s) com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Read (Select)

Recupera registros da tabela com base em critérios específicos (ou todos).
Comando SQL: SELECT coluna1, coluna2, ... FROM nome_da_tabela WHERE condição;.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class ListarPessoas {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             Statement statement = conexao.createStatement();
             ResultSet resultado = statement.executeQuery("SELECT id, nome, idade FROM pessoas")) {
            while (resultado.next()) {
                int id = resultado.getInt("id");
                String nome = resultado.getString("nome");
                int idade = resultado.getInt("idade");
                System.out.println("ID: " + id + ", Nome: " + nome + ", Idade: " + idade);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Update

Modifica registros existentes na tabela.
Comando SQL: UPDATE nome_da_tabela SET coluna1 = novo_valor, coluna2 = novo_valor WHERE condição;.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class AtualizarPessoa {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        String novoNome = "Ricardo Silva";
        int idParaAtualizar = 1;

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             PreparedStatement pstmt = conexao.prepareStatement("UPDATE pessoas SET nome = ? WHERE id = ?")) {
            pstmt.setString(1, novoNome);
            pstmt.setInt(2, idParaAtualizar);
            int linhasAfetadas = pstmt.executeUpdate();
            System.out.println(linhasAfetadas + " linha(s) atualizada(s) com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Delete

Remove registros da tabela.
Comando SQL: DELETE FROM nome_da_tabela WHERE condição;.
Para remover todos os registros: DELETE FROM nome_da_tabela;.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class ExcluirPessoa {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/meubanco";
        String usuario = "meuusuario";
        String senha = "minhasenha";
        int idParaExcluir = 1;

        try (Connection conexao = DriverManager.getConnection(url, usuario, senha);
             PreparedStatement pstmt = conexao.prepareStatement("DELETE FROM pessoas WHERE id = ?")) {
            pstmt.setInt(1, idParaExcluir);
            int linhasAfetadas = pstmt.executeUpdate();
            System.out.println(linhasAfetadas + " linha(s) excluída(s) com sucesso!");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Exemplo de Sistema CRUD (Conceptual)

Uma aplicação CRUD típica teria classes ou métodos para cada operação:
- criarPessoa(String nome, int idade): Insere uma nova pessoa no banco.
- lerPessoa(int id): Recupera uma pessoa pelo ID.
- listarTodasPessoas(): Recupera todas as pessoas do banco.
- atualizarPessoa(int id, String novoNome, int novaIdade): Atualiza os dados de uma pessoa.
- excluirPessoa(int id): Remove uma pessoa pelo ID.
Cada método utilizaria a API JDBC para executar os comandos SQL correspondentes.
Poderia haver uma classe para representar a entidade "Pessoa" para facilitar a manipulação dos dados.

Atividade Prática 1: DDL no PostgreSQL

Crie um programa Java que:
1. Tente criar um banco de dados chamado escola.
2. Se o banco de dados já existir, tente excluí-lo e criá-lo novamente.
3. Conecte-se ao banco de dados escola.
4. Crie uma tabela chamada alunos com as seguintes colunas:
  - id (inteiro, chave primária, auto incremento)
  - nome (texto, não nulo)
  - matricula (texto, único)
5. Adicione uma coluna chamada curso (texto) à tabela alunos.
6. Remova a coluna matricula da tabela alunos.
7. Trunque a tabela alunos.
8. Exclua a tabela alunos.

Atividade Prática 2: CRUD no PostgreSQL

Crie um programa Java que:
1. Conecte-se ao banco de dados escola (assuma que a tabela alunos com as colunas id, nome, curso existe).
2. Insira três registros de alunos na tabela alunos.
3. Liste todos os alunos cadastrados, mostrando seus IDs, nomes e cursos.
4. Atualize o curso do aluno com o ID específico.
5. Liste novamente todos os alunos para verificar a atualização.
6. Exclua o aluno com um ID específico.
7. Liste mais uma vez todos os alunos para verificar a exclusão.

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
README.md		README.md

Macelot/java-file-sql

Folders and files

Latest commit

History

Repository files navigation

Ensinando Java: Leitura/Escrita em Arquivos e Acesso ao PostgreSQL

Tópicos

Java Leitura e Escrita em Arquivos

Introdução ao File I/O em Java

API de I/O do Java

Leitura de Arquivos TXT

Escrita em Arquivos TXT

Leitura de Arquivos CSV

Leitura de Arquivos CSV (Simples)

Leitura de Arquivos CSV (Apache Commons CSV)

Leitura de Arquivos CSV (Apache Commons CSV) - Exemplo

Escrita em Arquivos CSV

Escrita em Arquivos CSV (Simples)

Escrita em Arquivos CSV (Apache Commons CSV) - Exemplo

Leitura de Arquivos JSON

Leitura de Arquivos JSON (Jackson) - Exemplo

Escrita em Arquivos JSON (Jackson) - Exemplo

Atividade Prática: Leitura e Escrita de Arquivos

Java Acesso a Bancos de Dados PostgreSQL

Acesso a Bancos de Dados com JDBC

Conectando ao PostgreSQL com JDBC

Operações no Banco de Dados PostgreSQL

Operações DDL (Data Definition Language)

Create Database

Drop Database

Use Database

Create Table

Drop Table

Truncate Table

Alter Table

Operações CRUD (Create, Read, Update, Delete)

Create (Insert)

Read (Select)

Update

Delete

Exemplo de Sistema CRUD (Conceptual)

Atividade Prática 1: DDL no PostgreSQL

Atividade Prática 2: CRUD no PostgreSQL

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Packages