{"id":21009813,"url":"https://github.com/lorialawrencez/alura-java-ia","last_synced_at":"2026-05-18T04:12:59.516Z","repository":{"id":239865665,"uuid":"799009502","full_name":"LoriaLawrenceZ/Alura-Java-IA","owner":"LoriaLawrenceZ","description":"Repository for studies in Java and IA from ALURA","archived":false,"fork":false,"pushed_at":"2024-07-20T14:46:05.000Z","size":291,"stargazers_count":1,"open_issues_count":3,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-01-20T11:12:03.643Z","etag":null,"topics":["ai","alura","api","java","openai","openai-api"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/LoriaLawrenceZ.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-05-11T00:17:14.000Z","updated_at":"2024-07-20T14:46:08.000Z","dependencies_parsed_at":"2024-07-20T15:42:34.432Z","dependency_job_id":null,"html_url":"https://github.com/LoriaLawrenceZ/Alura-Java-IA","commit_stats":null,"previous_names":["lorialawrencez/alura-java-ia"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LoriaLawrenceZ%2FAlura-Java-IA","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LoriaLawrenceZ%2FAlura-Java-IA/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LoriaLawrenceZ%2FAlura-Java-IA/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/LoriaLawrenceZ%2FAlura-Java-IA/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/LoriaLawrenceZ","download_url":"https://codeload.github.com/LoriaLawrenceZ/Alura-Java-IA/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":243431592,"owners_count":20289918,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","alura","api","java","openai","openai-api"],"created_at":"2024-11-19T09:18:01.827Z","updated_at":"2025-10-11T07:33:07.334Z","avatar_url":"https://github.com/LoriaLawrenceZ.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Alura-Java-IA\r\n\r\nO **HTTP** (Hypertext Transfer Protocol) é um protocolo de comunicação que permite a transferência de informações na internet. Ele é a base para a comunicação entre navegadores e servidores Web, sendo utilizado para a transmissão de conteúdo como textos, imagens e vídeos.\r\n\r\nO **HTTP** foi desenvolvido na década de 1990 e é baseado em um modelo cliente-servidor, onde um cliente (navegador Web) faz requisições a um servidor para obter informações, e o servidor responde com os dados solicitados. O **HTTP** utiliza o **TCP* (Transmission Control Protocol) como protocolo de transporte para garantir a entrega confiável dos dados.\r\n\r\nO **HTTP** utiliza métodos para especificar o tipo de operação que deve ser realizada no servidor. Os principais métodos são **GET**, **POST**, **PUT** e **DELETE** . O método **GET** é utilizado para solicitar dados do servidor, enquanto o **POST** é utilizado para enviar informações para o servidor. O **PUT** é utilizado para atualizar informações no servidor e o **DELETE** é utilizado para remover informações.\r\n\r\nAlém dos métodos, o **HTTP** utiliza códigos de status para indicar o resultado da operação realizada. Os códigos de status variam de 100 a 599 e são divididos em cinco classes:\r\n\r\n- 1xx: Informações\r\n- 2xx: Sucesso\r\n- 3xx: Redirecionamento\r\n- 4xx: Erro do cliente\r\n- 5xx: Erro do servidor\r\n\r\n---\r\n\r\n# Lidando com Exceções\r\n\r\n## Hierarquia de Exceptions no JAVA\r\n\r\nNo Java, as exceções são organizadas em uma hierarquia de classes. Todas as exceções são subclasses da classe Throwable, sendo que ela possui duas subclasses principais: Exception e Error.\r\n\r\nAs exceções que herdam da classe Exception são chamadas de exceções verificadas (checked exceptions). Isso significa que essas exceções devem ser tratadas explicitamente em um bloco try-catch ou declaradas em uma cláusula throws na assinatura do método. Um exemplo é a classe de exceção `IOException`, que indica algum problema relacionado com leitura/escrita de dados.\r\n\r\nAs exceções que herdam da classe Error representam erros irrecuperáveis pelo sistema, como falta de memória ou falhas internas. Um exemplo é a classe de exceção `OutOfMemoryError`, que indica que o Java não conseguiu memória suficiente do sistema operacional para executar corretamente a aplicação.\r\n\r\nAlém disso, existe ainda a classe de exceção RuntimeException, que é uma subclasse direta de `Exception`, e as classes que herdam dela são chamadas de exceções não verificadas (unchecked exception). As exceções não verificadas indicam erros lógicos no código, como a `NullPointerException`, que indica o acesso a algum atributo ou método de um objeto que é nulo, ou seja, que não foi instanciado ou foi atributo ao valor `null`.\r\n\r\nAo lidar com exceções em um bloco try-catch, é importante considerar a hierarquia de exceções. É possível capturar exceções de uma classe mãe em um bloco catch que captura exceções de uma classe filha. No entanto, o inverso não é possível. Isso significa que, se um bloco catch captura exceções de uma classe filha, ele não será capaz de capturar exceções de uma classe mãe.\r\n\r\nExemplo: Imagine uma exceção `IOException` (classe mãe) e uma exceção `FileNotFoundException` (classe filha). Um bloco catch que captura `IOException` irá capturar tanto `IOException` quanto `FileNotFoundException`, pois `FileNotFoundException` é um tipo específico de `IOException`. No entanto, um bloco catch que captura `FileNotFoundException` não irá capturar `IOException`.\r\n\r\nÉ importante lembrar que, ao usar a hierarquia de classes para tratar exceções, devemos priorizar o tratamento específico de exceções de classes filhas. Em seguida, podemos incluir um bloco catch mais genérico para tratar exceções de classes mães.\r\n\r\n## Multi-catch\r\n\r\nA partir do Java 7, a linguagem introduziu uma nova funcionalidade chamada \"multi-catch\", que permite capturar várias exceções em um único bloco catch. Essa funcionalidade pode tornar o código mais conciso e legível, reduzindo a repetição de código.\r\n\r\nO uso de multi-catch é muito simples. Em vez de ter vários blocos catch para lidar com diferentes exceções, você pode agrupá-las em um único bloco usando o caractere | para separar as exceções. Por exemplo, suponha que você tenha escrito o seguinte código:\r\n\r\n~~~Java\r\ntry {\r\n    metodoQuePodeLancarExcecao();\r\n} catch (NumberFormatException e) {\r\n    System.out.println(\"tratando erro...\");\r\n} catch (IllegalArgumentException e) {\r\n    System.out.println(\"tratando erro...\");\r\n}\r\n~~~\r\n\r\nComo o tratamento do erro é o mesmo para ambas as exceções, o código anterior poderia ter sido escrito utilizando o multi-catch:\r\n\r\n~~~Java\r\ntry {\r\n    metodoQuePodeLancarExcecao();\r\n} catch (NullPointerException | IllegalArgumentException e) {\r\n    System.out.println(\"tratando erro...\");\r\n}\r\n~~~\r\n\r\nNo exemplo anterior, estamos lidando com duas exceções diferentes: `NullPointerException` e `IllegalArgumentException`. Se qualquer uma dessas exceções for lançada dentro do bloco try, o mesmo bloco catch será executado.\r\n\r\nUma observação importante de lembrar, é que o uso de multi-catch só é permitido para exceções que não estão relacionadas por uma hierarquia de herança. Se duas exceções compartilham uma hierarquia de herança, você deve lidar com elas em blocos catch separados.\r\n\r\n# Persistindo Dados em Arquivos\r\n\r\n## O Pacote *java.io*\r\n\r\nO Java possui um pacote chamado java.io, que é um dos pacotes mais importantes da linguagem, pois fornece classes e interfaces para entrada e saída de dados em vários formatos, como arquivos, rede, teclado, dentre outros. Vamos conhecer as principais classes desse pacote.\r\n\r\n### A classe *File*\r\n\r\nA classe **File** representa um arquivo ou diretório no sistema de arquivos do computador, permitindo que você crie, delete, liste e manipule arquivos e diretórios. Para criar um objeto `File`, você precisa passar o caminho do arquivo ou diretório como argumento para o construtor. Por exemplo:\r\n\r\n~~~Java\r\nFile file = new File(\"C:\\\\meuArquivo.txt\");\r\n~~~\r\n\r\nNo código anterior, foi criado um objeto `File` que aponta para o arquivo \"meuArquivo.txt\" localizado na raiz do disco `C:`.\r\n\r\nA classe File tem vários métodos úteis para interagir com arquivos e diretórios, como `exists()`, `canRead()`, `canWrite()`, `isDirectory()`, `isFile()`, `mkdir()` e `delete()`.\r\n\r\n### As classes *FileReader* e *FileWriter*\r\n\r\nAs classes **FileReader** e **FileWriter** são usadas para ler e escrever dados em arquivos de texto, sendo que a classe `FileReader` lê os caracteres de um arquivo de texto, enquanto a classe `FileWriter` escreve os caracteres.\r\n\r\nPara usar a classe `FileReader`, você precisa criar um objeto passando um objeto `File` que deseja ler como argumento. Em seguida, você pode ler os dados do arquivo usando o método `read()` ou `read(char[])`. Por exemplo:\r\n\r\n~~~Java\r\nFile file = new File(\"C:\\\\meuArquivo.txt\");\r\nFileReader reader = new FileReader(file);\r\n\r\nint data = reader.read();\r\nwhile (data != -1) {\r\n    System.out.print((char) data);\r\n    data = reader.read();\r\n}\r\nreader.close();\r\n~~~\r\n\r\nNo código anterior, é feita a leitura do conteúdo do arquivo \"meuArquivo.txt\" e seu conteúdo é impresso no console.\r\n\r\nJá a classe `FileWriter` segue o mesmo processo, porém fazendo o caminho inverso, ou seja, escrevendo caracteres no arquivo. Por exemplo:\r\n\r\n~~~Java\r\nFile file = new File(\"C:\\\\saida.txt\");\r\nFileWriter writer = new FileWriter(file);\r\nwriter.write(\"Olá, mundo!\");\r\nwriter.close();\r\n~~~\r\n\r\nNo código anterior, é escrito uma mensagem no arquivo chamado \"saida.txt\".\r\n\r\nO pacote java.io também fornece outras classes úteis, como:\r\n\r\n- **BufferedReader** e **BufferedWriter**: são usadas para ler e gravar arquivos de texto de maneira eficiente, lendo e escrevendo uma linha por vez. Elas usam um buffer para armazenar os dados, o que torna a leitura e escrita mais rápida do que quando feita um caractere por vez;\r\n- **FileInputStream** e **FileOutputStream**: são usadas para ler e gravar dados binários em um arquivo. Eles são usados para ler e gravar dados em arquivos que não são de texto, como imagens e arquivos de áudio;\r\n- **ObjectInputStream** e **ObjectOutputStream**: são usadas para ler e gravar objetos em arquivos. Isso permite que você armazene objetos Java em arquivos para uso posterior ou para transferência entre diferentes aplicações. \r\n \r\nClaro, além dessas há também a classe **FileWriter**, que foi utilizada no curso para a escrita simples de um arquivo no computador, e também a classe `Scanner`, que é utilizada para ler arquivos do computador de uma maneira simples e será explicada posteriormente no curso.\r\n\r\n### Lendo Arquivos com *Scanner*\r\n\r\nAprendemos a salvar um arquivo, via classe `FileWriter`, mas caso você queira fazer o caminho contrário, ou seja, ler o conteúdo de um arquivo existente em Java, pode fazer isso com a utilização da classe Scanner.\r\n\r\nA classe `Scanner` é uma classe padrão do Java que permite ler dados de diferentes fontes, incluindo arquivos. Para ler um arquivo com essa classe, basta criar uma instância dela e passar como argumento um objeto do tipo `File`, contendo o caminho do arquivo. Por exemplo:\r\n\r\n~~~Java\r\nimport java.io.File;\r\nimport java.io.FileNotFoundException;\r\nimport java.util.Scanner;\r\n\r\npublic class LeituraDeArquivo {\r\n    public static void main(String[] args) {\r\n        try {\r\n            File arquivo = new File(\"arquivo.json\");\r\n            Scanner scanner = new Scanner(arquivo);\r\n\r\n            while (scanner.hasNextLine()) {\r\n                String linha = scanner.nextLine();\r\n                System.out.println(linha);\r\n            }\r\n\r\n            scanner.close();\r\n        } catch (FileNotFoundException e) {\r\n            System.out.println(\"Arquivo não encontrado!\");\r\n        }\r\n    }\r\n}\r\n~~~\r\n\r\nNo código anterior, estamos lendo um arquivo chamado `arquivo.json` e imprimindo o conteúdo do arquivo linha por linha no console. O método `hasNextLine()` verifica se há mais linhas a serem lidas, enquanto o método `nextLine()` lê a próxima linha do arquivo.\r\n\r\nA classe Scanner também pode ser usada para ler dados de entrada de outras fontes, como o teclado e strings. Além disso, ela oferece muitas opções para personalizar a forma como os dados são lidos, incluindo a capacidade de usar expressões regulares para analisar o texto.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Florialawrencez%2Falura-java-ia","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Florialawrencez%2Falura-java-ia","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Florialawrencez%2Falura-java-ia/lists"}