Como vimos em um artigo anterior sobre o tipo enum em Java, uma enumeração habilita uma variável a ser configurada com valores constantes pré-definidos. Ao atribuir valores a essa variável durante a execução do programa, somente são aceitos valores presentes da lista definida da enumeração.

Aplicação: usamos tipos de enumeração sempre que precisamos representas um conjunto fixo de constantes, valores que são totalmente conhecidos na hora da compilação do programa.

Exemplos comuns de aplicação de enums são a criação de variáveis para armazenar meses do ano, dias da semana, pontos cardeais, estações do ano, planetas do sistema solar, etc.

Importante notar que, por serem constantes, os nomes dos valores dentro de um tipo enum são escritos sempre em letras maiúsculas.

Neste artigo vamos criar uma enumeração em Java, e também uma classe que será usada para interagir com a enumeração, contendo um campo do tipo enum, um método construtor e um método de uso geral para exibição de uma mensagem ao usuário, dependendo do valor da enum que for solicitado no programa principal.

Crie um novo projeto Java em um IDE, criando uma classe principal main(). Meu projeto recebeu o nome de EnumsJava.

Criar uma enum em Java

Vamos criar primeiramente um tipo enum para armazenar os nomes dos planetas do Sistema Solar. Vamos chamar essa enum de EnumPlanetas. Para isso, crie um novo arquivo em seu IDE preferido e digite o código a seguir:

Código:

package enums;
public enum EnumPlanetas {
    MERCÚRIO,
    VÊNUS,
    TERRA,
    MARTE,
    JÚPITER,
    SATURNO,
    URANO,
    NETUNO
}

Testar a enum no programa principal

Vamos testar a enum criada no programa principal usando um laço de repetição para iterar pelos seus itens constituintes, exibindo cada nome da enum na tela.

Código:

package enums;
import java.util.Scanner;
public class EnumsJava {
  public static void main(String[] args) {
    // listar os valores possíveis para a enumeração:
    for (EnumPlanetas p : EnumPlanetas.values()) {
      System.out.printf("%s%n", p);
    }
  }
}

Devem ser exibidos na tela os nomes dos planetas, um por linha:

Criar classe para manipulação da enum

Agora vamos criar uma nova classe para trabalhar com a enumeração de planetas. Vamos batizar essa classe como ClasseTesteEnum. Crie um novo arquivo e digite o código a seguir. 

Código:

package enums;
public class ClasseTesteEnum {
  EnumPlanetas planeta;
  ClasseTesteEnum(String planeta) {
    this.planeta = EnumPlanetas.valueOf(planeta); // converte string para valor de enum
  }
  public void viajarPlaneta() {
    switch(planeta) {
      case MERCÚRIO:
        System.out.println("Muito quente por lá");
        break;
      case TERRA:
        System.out.println("Já estamos aqui");
        break;
      case SATURNO:
        System.out.println("Belíssimos anéis!");
        break;
     case URANO:
        System.out.println("Muito longe");
        break;
     default:
        System.out.println("Passagens esgotadas!");
        break;
    }
  }
}

Note que não criamos casos para todos os planetas listados na enumeração – esses serão tratados pelo caso default da declaração switch.

Salve o arquivo. Vamos testar o programa logo em seguida.

Testar a classe no programa principal

Vamos testar a classe criada instanciando-a no programa principal, e criando assim um objeto que chamaremos de pl.

Código:

package enums;
import java.util.Scanner;
public class EnumsJava {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    String planeta;
    System.out.println("Para qual planeta deseja viajar?");
    planeta = entrada.next().toUpperCase(); // converte para maiúsculas, pois os valores da enum são sempre maiúsculos
    entrada.close();
    // Criar o objeto pl
    ClasseTesteEnum pl = new ClasseTesteEnum(planeta);
    pl.viajarPlaneta();
  }
}

Testando com o planeta Urano:

Vamos testar agora com o planeta Marte:

E, finalmente, um teste com o planeta-anão Ceres (este não existe na listagem da enumeração):

A o tentar rodar o programa passando o valor Ceres (um planeta-anão do Sistema Solar), é retornado um erro, pois esse valor não pertence à enumeração, que somente aceita os valores constantes que foram definidos em sua declaração. A exceção lançada é java.lang.IllegalArgumentException: No enum constant enumsJava.EnumPlanetas.CERES.
Neste caso, devemos tratar a exceção de alguma forma para que o erro não prejudique a execução do programa.

Agora aproveite e assista ao vídeo do canal Bóson Treinamentos sobre o assunto:

O post Tipo enum em Java e classe de teste apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Por conta de atualizações na política de licenciamento do Java pela Oracle, que incluem o fim de determinadas atualizações gratuitas, entre outras alterações, muitos tem buscado alternativas para o uso do Java em seus sistemas, seja usando uma máquina virtual Java, um ambiente de execução, ou ainda para desenvolvimento de software na linguagem.

O AdoptOpenJDK é uma distribuição Java de código aberto, mantida por uma comunidade de desenvolvedores, que fornece binários pré-compilados da implementação de referência da plataforma Java a partir do OpenJDK, que por si é uma implementação livre e de código aberto da plataforma Java SE (Standard Edition).

Com o AdoptOpenJDK, as atualizações do Java são disponibilizadas com rapidez e regularidade a todos que usem seus pacotes. Empresas que contribuem para esse projeto incluem a IBM, Microsoft e Azul, entre outras, o que ajuda a manter o padrão de qualidade do projeto em um patamar bastante elevado.

O AdoptOpenJDK está disponível em diversas plataformas, como Windows, macOS e, claro, Linux, que será o objeto de nosso tutorial de hoje.

Vou mostrar como instalar o AdoptOpenJDK no Linux Debian e seus derivados, como o Ubuntu, MX Linux e Linux Mint, entre outros.

O site oficial do projeto AdoptOpenJDK é o https://adoptopenjdk.net/.

Vamos aos procedimentos de instalação e configuração agora.

Instalação do AdoptOpenJDK

O primeiro passo é importar a chave GPG de criptografia. Abra o terminal e execute o comando a seguir:

$ wget -qO - https://adoptopenjdk.jfrog.io/adoptopenjdk/api/gpg/key/public | sudo apt-key add -

Na sequência, adicione o repositório de pacotes do AdoptOpenJDK:

$ sudo add-apt-repository --yes https://adoptopenjdk.jfrog.io/adoptopenjdk/deb/

Atualizar a lista de pacotes dos repositórios no sistema:

$ sudo apt update

Finalmente, vamos instalar o AdoptOpenJDK no Linux:

$ sudo apt install adoptopenjdk-8-hotspot

Verifique no site do projeto as versões mais recentes do AdoptOpenJDK. Se preferir, você pode instalá-la simplesmente alterando o nome do pacote no comando anterior. Por exemplo, para a versão 11 você usa o pacote adopopenjdk-11-hotspot.

Após o término da instalação do pacote e suas dependências, podemos selecionar a alternativa Java a ser usada no sistema (qual JVM será usada), caso você tenha mais de uma JVM instalada (openJDK, Oracle JDK). Digite o número correspondente ao pacote desejado e pressione <enter>

$ sudo update-alternatives --config java

No meu caso possuo mais JVMs instaladas, e o AdoptOpenJDK é a opção número 1 na lista. Anote o caminho do executável do Java mostrado (/usr/bin/java), pois ele será necessário na próxima etapa, que é a configuração da variável de ambiente.

Agora vamos configurar a variável de ambiente JAVA_HOME no sistema. Para tal, abra o arquivo /etc/environment em um editor de textos qualquer. Este arquivo é o local padrão para a configuração de variáveis de ambiente em sistema Linux. Vou usar o nano para editá-lo:

$ sudo nano /etc/environment

Adicionar a linha a seguir, substituindo o caminho indicado em itálico pelo caminho do binário mostrado na saída do comando anterior (não se esqueça de incluir as aspas):

JAVA_HOME="caminho_obtido_no_comando_anterior_até_bin"

No meu caso ficou assim:

JAVA_HOME="/usr/bin/"

Salve o arquivo e feche-o. Logo após, faça logoff e logon no sistema novamente, para recarregar o arquivo para todos os usuários e processos (não é necessário reiniciar o computador).

Após logar novamente, abra o terminal e verifique a variável de ambiente configurada com o comando a seguir:

$ echo $JAVA_HOME

Perfeito! JDK instalado e configurado com sucesso em seus sistema! Para testar, instale algum programa que necessite do Java para rodar, como por exemplo o Portugol Studio – e aproveite para estudar lógica de programação com ele!

Até!

O post Como instalar o pacote AdoptOpenJDK no Linux Debian apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Finalmente chegamos ao final do ano de 2020. Para boa parte das pessoas, um ano para esquecer – para mim, sem dúvida, um dos piores períodos em diversos quesitos.

Esperamos que o próximo ano seja melhor – e vamos trabalhar para que isso se concretize. Uma das melhores coisas que podemos fazer é nos prepararmos de forma metódica e planejada, e estudar para enriquecer nosso currículo profissional e avançar em nossas carreiras é o caminho a seguir.

Por conta disso trago neste artigo algumas dicas de linguagens de programação que valem a pena estudar durante o ano vindouro, de forma bem objetiva e clara: apenas linguagens com real potencial de trazer benefícios ao estudante / profissional.

Escolher uma linguagem de programação

Aprender uma nova linguagem de programação não é uma tarefa simples, principalmente se você for iniciante. O processo pode ser demorado, complicado e frustrante – e no final você pode acabar usando seu tempo precioso para estudar uma linguagem de programação que não terá tanta utilidade em suas vida profissional.

Por isso é importante saber escolher qual linguagem (ou quais) você irá estudar. As opções são muitas, e algumas linguagens que hoje parecem muito importantes talvez percam relevância no futuro, ao passo que linguagens mais “obscuras” podem se tornar de uso comum e muito procuradas pelos profissionais e pelas empresas.

Existem literalmente centenas de linguagens de programação disponíveis hoje, e a demanda por essas linguagens varia ano a ano, com novas linguagens surgindo, outras se tornando mais populares, e outras tantas sendo menos utilizadas até se tornarem praticamente obsoletas.

Escolher uma linguagem de programação pode ser complicado – afinal, você pode acabar usando seu precioso tempo para aprender uma linguagem que, daqui a um ano (ou alguns meses!) não será mais relevante no mercado. Então, como escolher a linguagem (ou linguagens) mais indicadas para aprendizado, que tenham maior potencial de retorno para sua carreira?

Se você é iniciante no mundo do desenvolvimento de sistemas, a dica é investir nas linguagens mais consagradas, que tem ampla aceitação no mercado e utilização profunda pelas empresas – levando em consideração alguns fatores como crescimento de sua popularidade, nichos de atuação, novos entrantes (novas linguagens) que as possam substituir, quantidade de frameworks e bibliotecas disponíveis, demanda no mercado de trabalho, e outros.

As primeiras linguagens de programação com as quais tive contato foram Delphi, C, Basic e Assembly. Destas, apenas a linguagem C ainda é relevante nos dias de hoje – e, curiosamente, uma das mais importantes e estudadas ainda!

Porém as outras três acabaram se tornando obsoletas (Basic, Delphi) ou sendo usadas apenas em nichos muito específicos (Assembly, de novo Delphi). O mesmo deve acontecer com a maioria das linguagens mais novas que temos disponíveis – algumas serão usadas de forma intensiva pelos próximos anos ou até décadas, ao passo que outras são deixadas de lado rapidamente, substituídas por outras linguagens com mais recursos, mais performáticas ou simplesmente mais fáceis de aprender.

Neste artigo listo algumas das linguagens de programação que eu, pessoalmente, acredito que sejam importantes em 2021, e nas quais pode valer a pena investir tempo de estudo (e dinheiro, em alguns casos).

Bem, sem mais delongas, vamos à lista de linguagens para aprender em 2021!

JavaScript

O JavaScript é uma das linguagens mais usadas no mundo, encontrando aplicação em dispositivos móveis, desenvolvimento de jogos, Internet das Coisas e, principalmente, desenvolvimento Web.

Amplamente empregada no desenvolvimento de aplicações front-end para websites, também pode ser usada em aplicações de back-end (lado servidor), com o ambiente de execução NodeJS.

Não é exatamente uma linguagem simples de se aprender, devido à sua sintaxe, comandos e integração com outras linguagens, mas sem dúvida é uma das mais importantes, e você deve estudar JavaScript com certeza absoluta se tem a mínima intenção de trabalhar com desenvolvimento para Web e afins. O JS é executado normalmente em um navegador, oferecendo uma interface bastante responsiva para as aplicações web, sem a necessidade de compilação de código.

C++ (e C)

O C++ é a linguagem mais antiga dessa minha lista, mas não por isso menos importante que as demais.

Na prática, eu listaria C/C++, pois as duas linguagens tem muitos pontos em comum – mas o paradigma orientado a objetos do C++ faz com que seja mais simples (menos complicado?) desenvolver sistemas nesta linguagem. Mas recomendo também a linguagem C, uma das mais usadas no mundo hoje e a mais importante da história da programação.

Desenvolvida por Bjarne Stroustrup em 1985, o C++ é uma das linguagens mais eficientes e flexíveis que existem, permitindo a criação de aplicações de alta performance e alta confiabilidade, sendo empregada em áreas diversas como Programação de Sistemas, Desenvolvimento de Jogos, Aplicações para Web e Desktop, Área Financeira, Sistemas Embarcados, Aplicações de Tempo Real, Veículos Autônomos e Inteligência Artificial, entre outras.

E é justamente essa demanda de sistemas autônomos, embarcados e jogos de alta performance que fazem com que o C/C++ esteja presente nesta lista. São linguagens antigas e ao mesmo tempo suportam as tecnologias do futuro!

Uma das grandes desvantagens do C++ é sua curva de aprendizado acentuada, pois possui uma sintaxe complexa, e seu sistema de orientação a objetos não é tão claro quanto, por exemplo, o da linguagem Java. Também peca em alguns pontos como a alocação de memória dinâmica ou coletor de lixo. Não é recomendada como linguagem de escolha para iniciantes em programação.
Porém, aplicações escritas em C e C++ são extremamente rápidas, sendo insubstituíveis em muitos casos.

Java

Criada por James Gosling em 1995 na Sun Microsystems, é provavelmente a linguagem mais usada atualmente em ambiente empresarial. Totalmente orientada a objetos, aplicações escritas em Java podem rodar em qualquer plataforma, bastando para isso ter alguma implementação de Máquina Virtual Java instalada (JVM). É ideal para aplicações de computação distribuída, além de suportar multithreading.

Suas principais aplicações são no desenvolvimento de aplicações Desktop (como o notório programa da Imposto de Renda!), aplicações Web e Mobile (para Android), e nas áreas de serviços Financeiros e aplicações Científicas, entre outras. O Java possui uma variedade enorme de bibliotecas open source e diversas APIs, que facilitam o desenvolvimento de aplicações que envolvam bancos de dados, conectividade à redes, manipulação de formatos variados de dados e muito mais.

Uma de suas desvantagens é o fato do ambiente Java se relativamente “pesado”, demandando recursos de hardware específicos, além de ser mais lenta (é interpretada) em comparação com aplicações escritas em linguagens como C/C++ (que são compiladas). O gerenciamento de memória também não é excelente.

PHP

Podem fazer memes e falarem o que quiserem, mas o PHP ainda é linguagem dominante em aplicações Web Back End. Quase 1/4 dos websites na Internet usam PHP de alguma forma, sendo empregada primariamente na criação de websites dinâmicos e blogs, como os criados usando a plataforma WordPress.

Linguagem multiparadigma (funcional, imperativa, orientada a objetos) lançada em 1995, o PHP possui um vasto ecossistema de aplicações e bibliotecas, e uma grande comunidade para suporte, alé de diversos frameworks que facilitam o desenvolvimento de aplicações na linguagem (como o Laravel).

O PHP hoje sofre competição de linguagens como o Python e o JavaScript (Node), mas ainda impera no quesito linguagem server-side para web. Sua facilidade de aprendizado e a grande quantidade de bibliotecas e frameworks a tornam uma linguagem ideal para quem está iniciando em desenvolvimento web e deseja se inserir no mercado de trabalho sem necessariamente trabalhar com front end (HTML/CSS).

As maiores criticas ao PHP recaem sobre características de segurança e gerenciamento de erros um pouco deficiente, que demandam um maior cuidado ao desenvolver sistemas e aplicações que tratam dados mais sensíveis. Além disso não é tão veloz quanto se espera de uma linguagem de back end.

Python

Python, desenvolvida por Guido van Rossum em Amsterdam, na Holanda em 1990, é minha escolha número um para 2021. Uma das linguagens mais versáteis que existem atualmente, pode ser empregada no desenvolvimento de aplicações para inúmeras áreas, sendo dominante em Ciência de Dados, Machine Learning e Automação em geral. Mas o Python também pode ser utilizado para desenvolver aplicações Web, Desktop, para servidores de Rede, IoT (Internet das Coisas) e muito mais.

Além disso, sua sintaxe muito clara e organizada permite que seja aprendida com bastante facilidade, e em menor tempo que as outras linguagens, sendo por isso muito recomendada para iniciantes em programação em geral. É uma das linguagens mais utilizadas no mundo atualmente, além de ser altamente extensível com o emprego de suas inúmeras bibliotecas, como Matplotlib, Pandas, NumPy e diversas outras.

De acordo com o índice TIOBE de linguagens de programação, o Python é a terceira linguagem mais popular no mundo, atrás apenas das linguagens C e Java (desta última por uma pequena margem de menos de 0,4%):

Índice TIOBE – 12/2020. Fonte: www.tiobe.com/tiobe-index/

Sua maior desvantagem é que o Python é relativamente lento em comparação com outras linguagens, pois se trata de uma linguagem interpretada, de modo que para algumas aplicações, como sistemas de tempo real, não é a tecnologia mais indicada.

Outras linguagens

Além das cinco linguagens de programação citadas anteriormente, destaco mais duas (dessa vez, apostas) que podem ter impacto em seu currículo e em sua carreira. Uma delas é a linguagem Go (Golang), que vem crescendo paulatinamente, e a outra é a linguagem R, de nicho mais específico (ciência de dados / análise estatística), bastante utilizada no meio profissional.

Linguagem Go

Linguagem de programação criada pelo Google, também conhecida como Golang. Uma de suas principais características é o excelente suporte a multithreading, sendo ideal para o desenvolvimento de aplicações para sistemas distribuídos de grande porte.

É uma linguagem relativamente simples de aprender, devido à sua sintaxe clara e objetiva, mas ainda assim não tão fácil quanto o Python. Porém é bem rápida, sendo compilada em código de máquina, e se você trabalha em projetos de software de grande porte, que emprega processamento pesado em paralelizado, a linguagem Go é uma ótima escolha.

Linguagem R

A linguagem R, desenvolvida por Robert Gentleman e Ross Ihaka na Universidade de Auckland (Nova Zelândia) em 1992, é uma linguagem de código aberto para análise de dados estatística, amplamente empregada nas áreas de Ciência de Dados, Computação Estatística, Big Data e Aprendizado de Máquina. Seu aprendizado não é tão simples quanto o da linguagem Python, porém possui um rico ecossistema de pacotes, bibliotecas e ferramentas, incluindo bibliotecas para visualização gráfica de dados de alto padrão.

Permite o desenvolvimento de algoritmos para aprendizado de máquina altamente complexos e poderosos, e por conta dessas características é usada por muitas organizações atualmente.

Entre os pontos fracos do R podemos citar o gerenciamento de memória, não tão eficiente, e a falta de padrões de segurança mais elevados. Mas isso acaba não afetando o uso da linguagem, pois seu rico conjunto de ferramentas compensa facilmente essas deficiências.

Conclusão

Mostrei neste artigo cinco linguagens de programação para aprender em 2021 (que eu acredito serem relevantes em 2021), e nas quais vale a pena investir seu tempo de estudo. Não há nenhuma novidade ou grande surpresa na lista, pois afinal as linguagens apresentadas são as dominantes no mercado em seus nichos específicos, e todas tem grande potencial de te ajudar a alavancar sua carreira em tecnologia. 

É evidente que, se você pretende trabalhar, por exemplo, com desenvolvimento Web, deve dar preferência ao estudo de JavaScript e PHP em vez de C/C++ ou R; já se pretende trabalhar com ciência de dados, deve focar seus esforços no Python e linguagem R (e outras, como a linguagem Julia – assunto para um outro artigo!).

É isso aí! Bom final de ano a todos (e que o ano termine logo), e nos vemos em 2021. Abraço!

O post 5 Linguagens de Programação para aprender em 2021 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como instalar a implementação Java OpenJDK no Debian Linux 10 e derivados, para desenvolvimento de aplicações e execução de software em Java e outras linguagens específicas.

O que é JDK

O Oracle JDK, abreviação de Java Development Kit (Kit de Desenvolvimento Java), é um conjunto de utilitários e bibliotecas que permitem criar e testar aplicações na plataforma Java e outras, como Scala. Além do JDK, outros dois componentes são empregados no desenvolvimento em Java: o JRE (Java Runtime Environment) e a JVM (Java Virtual Machine).

Sendo assim, temos que a plataforma Java é composta de:

• JVM é o componente da plataforma Java que executa os programas
• JRE são os pacotes que criam o ambiente de execução Java (a JVM)
• e o JDK é o conjunto que permite aos desenvolvedores criar os programas que são executados pela JVM no JRE.

O JDK foi desenvolvido inicialmente pela Sun Microsystem e e mantido atualmente pela Oracle Corporation e, portanto, é software proprietário, sendo distribuído sob licença comercial.

O que é o OpenJDK

O OpenJDK é uma implementação em software livre do JDK, na edição Standard (Java SE). Sendo assim, é distribuído sob licença GNU GPL e está disponível em inúmeras plataformas, como Linux, Unix, BSD, macOS e Windows.

A versão mais atual da implementação é a versão 11, e o site oficial do projeto OpenJDK é o https://openjdk.java.net/

Instalação do OpenJDK no Linux

Iniciamos a instalação executando a atualização da lista de pacotes do sistema e rodando o gerenciador de pacotes APT para instalar o pacote default-jdk, como segue:

$ sudo apt update
$ sudo apt install default-jdk

Após instalar os pacotes necessários podemos verificar a instalação do OpenJDK com os comandos a seguir:

$ java --version
$ javac --version

O Java Runtime Environment está incluído no pacote JDK. Se for necessário apenas o ambiente de execução Java (JRE), instale somente o pacote JRE:

$ sudo apt install default-jre

Como ajustar a variável de ambiente do Java

Após instalar o OpenJDK em seu sistema é importante configurar a variável de ambiente $JAVA_HOME, para que o executável possa ser utilizado sem problemas a partir de qualquer diretório ou aplicação na máquina. Para tal, siga os passo abaixo:

Verificar caminho de instalação do Java

$ sudo update-alternatives --config java

Abra o arquivo /etc/environment para ajustar o caminho do ambiente de execução para todos os usuários:

$ sudo nano /etc/environment

Acrescente neste arquivo o caminho do Java consultado anteriormente, da seguinte forma (o arquivo executável em si não entra no caminho informado aqui):

JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64/"

Salve e feche o arquivo.

Agora, recarregue o arquivo:

$ sudo source /etc/environment

Verifique se o caminho foi configurado corretamente, consultando a variável JAVA_HOME:

$ echo $JAVA_HOME

Para aplicar essa configuração aos outros usuários, execute esse comando em seus sistemas ou simplesmente faça logoff e login novamente em suas respectivas contas.

E se eu quiser instalar o JDK / JRE oficiais da Oracle (Oracle JDK 12)? Veremos como fazer isso no próximo tutorial.

O post Como instalar o OpenJDK 11 no Linux Debian 10 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição passada vimos como criar e editar arquivos de texto de acesso sequencial em Java. Agora vamos mostrar como abrir e ler esses arquivos. Usaremos o arquivo criado anteriormente, arquivo.txt, no exemplo.

Note que vamos trabalhar com um arquivo cujo local de armazenamento no disco já é conhecido previamente, por isso o caminho do arquivo é hard-coded. Nas lições futuras mostraremos como escolher arquivos em locais aleatórios para leitura e edição.

O exemplo que usaremos foi adaptado de Deitel – Java How to Program, 10ª edição. A seguir, temos o código completo da aplicação.

Código

import java.io.IOException;
import java.lang.IllegalStateException;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class LerArquivoTexto
{
  private static Scanner entrada;
// programa principal
  public static void main(String[] args) {
    abrirArquivo();
    lerDados();
    fecharArquivo();
}
// Método para abrir o arquivo arquivo.txt
  public static void abrirArquivo() {
    try {
      entrada = new Scanner(Paths.get("c:\\Java\\arquivo.txt")); // Abrir o arquivo, salvo em C:\Java\
    }
    catch (IOException erroES) {
      System.err.println("Erro ao abrir o arquivo. Finalizando.");
      System.exit(1); // terminar o programa
    }
  }
// Método para ler os registros do arquivo
  public static void lerDados() {
    System.out.printf("%-10s%-15s%n","Código","Produto");
    try {
      while (entrada.hasNext()) { // enquanto houver dados para ler, mostrar os registros
        System.out.printf("%-10d%-12s%n",entrada.nextInt(),entrada.next());
      }
    }
    catch (NoSuchElementException erroElemento) {
      System.err.println("Arquivo com problemas. Finalizando.");
      entrada.nextLine(); // Descartar a entrada para que o usuário possa tentar de novo
    }
    catch (IllegalStateException erroEstado) {
      System.err.println("Erro ao ler o arquivo. Finalizando.");
    }
  } // fim do método lerDados
// Método para fechar o arquivo aberto
  public static void fecharArquivo() {
    if (entrada != null)
      entrada.close();
  }
} // Fim da classe LerArquivoTexto

Ao abrir o arquivo arquivo.txt usando o programa acima, vemos na tela o seguinte resultado:

Note que no programa principal executamos apenas três métodos: abrirArquivo, lerDados e fecharArquivo, para realizar as operações correspondentes. Todo o processamento é executado dentro desses métodos.

Anterior: Criar e editar arquivos de texto de acesso sequencial em Java

O post Como abrir e ler arquivos de texto de acesso sequencial em Java apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

As Collections são estruturas de dados pré-definidas, fornecidas pela API do Java, que são empregadas para armazenar grupos de objetos relacionados na memória durante a execução do programa. Com estas classes é possível organizar, armazenar e ler dados sem a necessidade de saber exatamente como os dados são armazenados (encapsulamento).

Um array convencional não tem seu tamanho modificado automaticamente durante a execução do programa, por exemplo para armazenar novos elementos, o que pode ser um problema, principalmente se surge a necessidade de armazenar mais elementos após um array estar completo.

O framework Collections em Java fornece diversas interfaces e classes para manipulação de grupos de objetos, como por exemplo:

• Interfaces
  • List
  • Set
  • Queue
  • Deque
  • SortedSet
• Classes
  • ArrayList
  • LinkedList
  • Vector
  • HashSet
  • PriorityQueue
  • LinkedHashSet
  • TreeSet

Nesta lição vamos iniciar o estudo das Collections com a classe ArrayList.

Classe ArrayList

A classe de coleção (collections class) ArrayList<T>, pertencente ao pacote java.util, e que implementa a interface List, resolve o problema de modificação do tamanho de um array em tempo de execução, pois ela pode mudar seu tamanho de forma dinâmica – ou seja, permite criar um array dinâmico. A letra T indica um placeholder, que é substituído ao declarar um ArrayList pelo tipo de elementos que a estrutura irá armazenar.
Suponha que desejemos criar um ArrayList de strings, de nome produtos. Para tal, executamos a seguinte declaração:

ArrayList<String> produtos;

Note que somente tipos não-primitivos podem ser usados para declarar variáveis e criar objetos em classes genéricas – e o ArrayList é uma classe genérica. Ainda assim, em Java é possível usar tipos primitivos, desde que empacotados como se fossem objetos, em um processo denominado boxing. Desta forma, poderíamos criar um ArrayList de inteiros também, por exemplo:

ArrayList<Integer> numeros;

Ao ler um valor deste ArrayList o elemento (valor inteiro) é desempacotado (processo de unboxing).

Métodos principais de um ArrayList

A seguir listamos os principais métodos fornecidos por uma classe ArrayList:

• Método add – Adiciona um elemento no final do ArrayList.
• Método clear – Remove todos os elementos da estrutura.
• Método contains – Verifica se o ArrayList contém um elemento especificado, e retorna true em caso positivo, ou false caso contrário.
• Método get – Retorna o item em uma posição de índice especificada.
• Método indexOf – Retorna a posição de índice da primeira ocorrência de um elemento especificado.
• Método remove – Remove a primeira ocorrência de um valor especificado ou de um elemento em um índice.
• Método size – Informa o número de elementos que estão armazenados na estrutura.
• Método trimToSize – Ajusta a capacidade do ArrayList de acordo com o número de elementos armazenados no momento.

Exemplo

Vejamos um exemplo de uso de ArrayList.

import java.util.ArrayList;
public class ListaArrayList {

public static void main(String[] args) {
  // Criar um novo ArrayList de Strings com capacidade inicial de 10 elementos (padrão)
  ArrayList<String> frutas = new ArrayList<>();

  frutas.add("Maçã"); // Adicionar um item à lista
  frutas.add(0, "Uva"); // Inserir a fruta Uva na posição de índice 0
  System.out.println("Mostrar o conteúdo do ArrayList usando laço for convencional:");

  for (int i = 0; i < frutas.size(); i++)
    System.out.printf(" %s", frutas.get(i));

  // Mostrar as frutas com o método mostrar(). Passamos a lista e um frase-cabeçalho
  mostrar(frutas,"%nMostrando a lista de frutas com o método mostrar:");

  frutas.add("Tangerina"); // Adicionar tangerina ao final da lista
  frutas.add("Morango"); // Idem com Morango
  mostrar(frutas, "Nova visualização da lista após adicionar frutas:");

  frutas.remove("Uva"); // remover a fruta Uva"
  mostrar(frutas, "Nova visualização da lista após remover frutas:");

  frutas.remove(1); // Remover item na posição de índice 1
  mostrar(frutas, "Remover o segundo elemento da lista (índice 1):");

  // Verificar número de elementos na lista
  System.out.printf("Tamanho atual do ArrayList: %s itens%n", frutas.size());

  // Verificar se um item existe na lista
  System.out.printf("A fruta \"Tangerina\" %sestá na lista%n", frutas.contains("Tangerina") ? "": "não ");
}

// criar método para mostrar os elementos do ArrayList frutas
public static void mostrar(ArrayList<String> frutas, String cabecalho) {
  System.out.printf(cabecalho); // mostrar cabeçalho

  for (String item : frutas)
    System.out.printf(" %s", item);
    System.out.println();
  }
}

Neste exemplo criamos um ArrayList de String chamado de frutas, e adicionamos dois nomes de frutas a ele usando o método add.

Logo após, mostramos o conteúdo do ArrayList iterando pelos seus elementos com um laço for, e lendo cada item com o método get.

Também criamos um método especial para mostrar o conteúdo do ArrayList, de nome mostrar(), que recebe como argumentos o nome do ArrayList e uma mensagem a ser exibida juntamente com os elementos retornados.

Removemos um elemento usando o método remove, e verificamos o seu tamanho com o método size.

Finalmente, verificamos se um item está contido no ArrayList usando o método contains.

Na próxima lição vamos estudar as listas ligadas, implementadas com a classe LinkedList.

O post A Classe ArrayList e Collections em Java apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um arquivo de acesso sequencial é um arquivo no qual os dados (registros) são armazenados em ordem, por um campo registro-chave. Vamos criar nesta lição um arquivo de texto, incluindo escrita, leitura e edição de seu conteúdo.

Criar classe para manipular arquivo de texto

Para nosso exemplo vamos criar a classe CriarArquivoTexto, que irá usar um objeto Formatter para gerar Strings formatadas, da mesma forma que o método System.out.printf trabalha. E com ele criaremos ou abriremos um arquivo de texto que nomearemos como “arquivo.txt“.

Se o arquivo não existir, ele será criado; caso o arquivo já exista no sistema, ele será truncado, ou seja, todo o seu conteúdo será apagado e substituído pelo novo conteúdo digitado.

Exemplo

Vejamos um exemplo de criação e edição de arquivo de texto em Java, adaptado de Deitel – Java How to Program, 10ª edição:

package criarArquivoTexto;
import java.io.FileNotFoundException;
import java.lang.SecurityException;
import java.util.Formatter;
import java.util.FormatterClosedException;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class CriarArquivoTexto {
  private static Formatter saida; // envia texto para um arquivo

    public static void main(String[] args) {
      abrirArquivo();
      adicionarDados();
      fecharArquivo();
    }

    // Método para abrir (ou criar) o arquivo arquivo.txt
    public static void abrirArquivo() {
      try {
        saida = new Formatter("arquivo.txt"); // Abrir o arquivo
      }
      catch (SecurityException securityException) {
        System.err.println("Não é possível escrever no arquivo. Finalizando.");
        System.exit(1); // terminar o programa
      }
      catch (FileNotFoundException fileNotFoundException) {
        System.err.println("Erro ao abrir o arquivo. Finalizando.");
        System.exit(1); // Finalizar o programa
      }
   }

    // Método para adicionar registros ao arquivo
    public static void adicionarDados() {
      Scanner entrada = new Scanner(System.in);
      System.out.printf("%s%n","Entre com o código do produto e nome do item para cadastro:");
      System.out.printf("%s%n","Para salvar os dados inseridos pressione Ctrl+Z:");
      while (entrada.hasNext()) { // iterar até que seja encontrado o marcador de fim-de-arquivo
        try {
          // Gravar novo registro no arquivo; não verifica se entrada é válida.
          saida.format("%d %s %n", entrada.nextInt(),entrada.next());
        }
        catch (FormatterClosedException formatterClosedException) {
          System.err.println("Erro ao escrever no arquivo. Finalizando.");
          break;
        }
        catch (NoSuchElementException elementException) {
          System.err.println("Entrada inválida. Tente novamente.");
          entrada.nextLine(); // Descartar a entrada para que o usuário possa tentar de novo
        }
        System.out.print("Entre com o próximo código e item:\n");
      } // Fim do laço while
    } // Fim do método adicionarDados

    // Método para fechar o arquivo
    public static void fecharArquivo() {
      if (saida != null)
        saida.close();
    }
} // Fim da classe CriarArquivoTexto

Note que para sinalizar o final de arquivo e sair do programa, usamos a combinação de teclas Ctrl+Z. Esse é o marcador EOF padrão no Windows. Se estiver usando outro sistema operacional, o marcador poderá ser diferente:

Após a execução do programa, podemos entrar na pasta do projeto e lá encontraremos o arquivo gerado. Se o abrirmos usando o editor de texto padrão do sistema, veremos o conteúdo que foi fornecido à aplicação anteriormente:

Arquivo criado e dados salvos com sucesso! Na próxima lição vamos aprender a ler os dados armazenados em um arquivo de texto sequencial usando Java.

O post Como criar e editar arquivos de texto de acesso sequencial em Java apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Os dados presentes na memória RAM do computador são temporários, o que significa que são perdidos em algum momento, por exemplo ao desligar a máquina. Isso inclui dados presentes nas variáveis dentro de um programa – como as aplicações Java – o que nos traz o seguinte problema: como armazenar dados de forma permanente, sem que haja perda de informação?

A questão é muito importante, pois é muito comum que haja a necessidade de armazenar informação para uso posterior. Para tal fazemos uso de arquivos, que são conjuntos de dados estruturados armazenados em dispositivos de armazenamento secundários, como um disco rígido, SSD ou mídia óptica, por exemplo. Dados gravados nesses dispositivos são dados persistentes – continuam existindo mesmo após terminada a execução de um programa.

Neste lição vamos introduzir a manipulação de arquivos em Java, mostrando como é possível obter informações sobre arquivos e diretórios existentes em uma mídia, como no HD do computador.

O que veremos neste tutorial:

• Quais classes manipulam arquivos em Java?
• O que são Streams em Java?
• O que são Dispositivos Especiais?
• Para que servem os pacotes java.io e java.nio?
• Como usar as classes Paths e Files em Java?

Classes para manipulação de arquivos em Java

Existem diversas classes e interfaces que permitem a manipulação de arquivos e pastas em Java. Vamos estudar as seguintes neste tutorial:

• Pacote java.nio.file
• Classe Paths
• Classe Files
• Interface Path
• Interface DirectoryStream

Fluxos (Streams)

Em Java, os arquivos são vistos como fluxos sequenciais de bytes (streams). Ao processar um arquivo, o Java processa um fluxo de bytes até encontrar um marcador especial que indica o final do fluxo – ou seja, o final do arquivo. Chamamos a esse marcados de Marcador de Fim-de-Arquivo (End-Of-File / EOF).

Os fluxos de dados podem ser de dois tipos:

• Baseado em Bytes – Os dados são lidos e gravados em formato binário (bits), de modo que, por exemplo, um dado do tipo int ocupe quatro bytes, um do tipo char, dois bytes, e assim sucessivamente, dependendo do tipo de dado. Arquivos criados com fluxo baseado em bytes são denominados Arquivos Binários.
  Somente programas que entendam a organização dos bytes são capazes de ler esse tipo de arquivo.
• Baseado em Caracteres – Neste caso, os dados são lidos e gravados como sequências de caracteres, sendo que cada caractere tem dois bytes de tamanho, e o tamanho de um dado depende, assim, do número de caracteres que ele possui. Arquivos criados com fluxo baseado em caracteres são denominados Arquivos de Texto.
  Editores de texto são capazes de ler este tipo de arquivo.

Fluxos e dispositivos especiais

Um fluxo de dados pode ser associado a diferentes dispositivos pelo Java. Ao iniciar um programa, o Java cria três objetos de fluxo, associados com dispositivos: System.in, System.out e System.err. Dois deles você provavelmente já viu em algum programa – lembra-se do System.in em um objeto Scanner, ou do System,out ao chamar um método printf ou println? Esses dispositivos representam o seguinte:

• System.in – Dispositivo de entrada padrão, que habilita um programa a receber dados oriundos do teclado.
• System.out – Saída padrão. Habilita o programa a enviar dados de saída à tela.
• System.err – Erro padrão. Permite que um programa envie mensagens de erro para a tela.

Esses fluxos de dados podem ser redirecionados, de modo que seja possível ler entrada de dados de outros dispositivos, por exemplo, ou enviá-los para outro local.

Pacotes java.io e java.nio

Esses pacotes possuem as classes e interfaces empregadas no processamento de fluxos de dados em Java. Vamos trabalhar com esses elementos em um programa simples, que irá mostrar dados sobre arquivos e diretórios especificados no console. Antes disso, vamos descrever as principais classes que serão empregadas:

• Interface Path – Os objetos de classes que implementam esta interface permitem representar o local de um arquivo ou diretório no sistema. Porém, não permitem abrir ou editar arquivos.
• Interface DirectoryStream – Os objetos de classes que implementam esta interface permitem que a aplicação seja capaz de iterar pelo conteúdo de uma pasta no sistema.
• Classe Paths – Esta classe fornece métodos estáticos que são empregados para obter um objeto Path, que representa o local de um arquivo ou diretório no sistema. Um objeto Path é criado por meio do uso do método estático get desta classe, o qual converte uma String que representa o local de um arquivo ou diretório no objeto.
• Classe Files – Esta classe fornece métodos estáticos que podem ser usados para realizar manipulação de arquivos e diretórios, como criar, excluir ou copiar arquivos, obter dados sobre arquivos e diretórios, ler o conteúdo de um arquivo, entre outros.

Exemplo

No exemplo mostrado a seguir, usamos as classes e interfaces apresentadas para obter informações sobre um arquivo ou diretório, cujo caminho é fornecido pelo usuário e lido por um objeto Scanner.

package lerGravarArquivos;
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;
public class LerGravarArquivos {

  public static void main(String[] args) throws IOException {

    Scanner entrada = new Scanner(System.in);
    System.out.println("Entre com o nome do arquivo ou diretório:");

    // Criar objeto Path com a entrada fornecida pelo usuário
    Path caminho = Paths.get(entrada.nextLine());

    // Verificar se o caminho existe, e mostrar informações sobre ele em caso positivo:
    if (Files.exists(caminho)) {
      System.out.printf("Nome do arquivo: %s%n", caminho.getFileName());
      System.out.printf("É diretório? %s%n",Files.isDirectory(caminho)?"Sim":"Não");
      System.out.printf("Última modificação: %s%n",Files.getLastModifiedTime(caminho));
      System.out.printf("Tamanho: %s%n",Files.size(caminho));
      System.out.printf("Caminho: %s%n",caminho);

      //Se for diretório, mostrar seu conteúdo:
      if (Files.isDirectory(caminho)) {
        System.out.println("Conteúdo do diretório:\n");
        DirectoryStream<Path> directoryStream = Files.newDirectoryStream(caminho);
        for (Path cam : directoryStream) {
          System.out.println(cam);
        }
      }
    }
    else { // Se o caminho não for arquivo ou diretório, apresentar mensagem de erro
      System.out.printf("%nO caminho %s não existe.",caminho);
    }
  }
}

Os métodos empregados são, basicamente, auto-explicativos. Note que é importante acrescentar a declaração throws IOException no método main, caso contrário alguns dos métodos empregados no programa não serão executados pelo compilador.

Nas próximas lições veremos como criar, editar e manipular arquivos de texto em Java.

O post Obter informações sobre arquivos e diretórios com Java e classes NIO apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Damos o nome de tokens às palavras individuais e marcas de pontuação (pontos, vírgulas, etc) que compõem e dão sentido a uma frase ou parágrafo de texto. Quando lemos um texto qualquer, nosso cérebro efetua a separação dessas palavras automaticamente, de modo a entendermos o significado do conteúdo lido.

Não só nós realizamos esse processo – compiladores, por exemplo, também realizam a separação de sentença e comandos em partes individuais, como palavras-chave, operadores, nomes de objetos e outros elementos que compõem o código-fonte.
Em outras palavras, os compiladores tokenizam o código para analisá-lo, antes de tentar executá-lo.

Em Java, é possível realizar essa separação de elementos em uma string – ou seja, tokenizar – por meio do emprego do método split, pertencente à classe String.

Método split – Divide um objeto String em seus tokens componentes, separados entre si por delimitadores especificados. Comumente, os delimitadores empregados são caracteres de espaço, tabulação, newline (quebra de linha), entre outros. Mas também é possível usar outros caracteres como delimitadores – por exemplo, é comum usar vírgulas em arquivos do tipo CSV (comma-separated values / valores separados por vírgulas).

O método split toma como argumento um caractere a ser considerado como delimitador.

Exemplo

Vejamos um exemplo de tokenização de uma String em Java.

Scanner entrada = new Scanner(System.in);
System.out.println("Digite um texto para ser dividido em seus tonkens constituintes, e pressione enter:");
String texto = entrada.nextLine();
// Realizar o processamento da frase, separando seus tokens
String[] tokens = texto.split(" ");
//Informar quantos tokens há na frase:
System.out.printf("%nA frase informada possui %d tokens.%n", tokens.length);
//Mostrar os tokens obtidos
System.out.println("Os tokens da frase são:\n");
for (String item : tokens) {
  System.out.println(item);
}

Neste exemplo, a frase informada é tokenizada pelo método split, que recebeu como argumento o delimitador espaço (” “), e os tokens individuais são armazenados em um array de String que chamamos de tokens. Assim, podemos acessar qualquer um dos tokens simplesmente lendo uma posição no array, ou imprimir todos eles, como fizemos no programa.

O post Como tokenizar strings em Java com o método split apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em Java é possível realizar conversão entre dados do tipo caractere e dígitos numéricos, em diversas bases, com o emprego de alguns métodos da classe Character. Neste tutorial veremos como fazer isso usando os métodos digit e forDigit.

• Método forDigit – Converte um dígito inteiro em caractere, na base (sistema de numeração) especificada pelo inteiro radix (base). Por exemplo, o valor inteiro decimal 15, ao ser convertido em seu caractere correspondente na base 16, é representado por ‘F’ (sem distinção entre maiúsculas e minúsculas). Sua sintaxe é a seguinte:

  forDigit(numero,base)

• Método digit – Converte um valor de caractere em um número inteiro especificado por um valor de base inteiro (radix). Por exemplo, o caractere ‘B’, na base 16, é convertido para o valor 11 na base 10 (decimal). O valor de base (radix) deve ser um número entre 2 e 36, inclusive. Sua sintaxe é a seguinte:

  digit(caractere,base)

Exemplo

Vejamos dois exemplos de conversão usando esses métodos em Java.

Scanner entrada = new Scanner(System.in);

System.out.println("Digite o valor da base numérica, entre 2 e 36:");
int base = entrada.nextInt();

System.out.println("\nDigite o caractere desejado para conversão:");
char caractere = entrada.next().charAt(0);

System.out.println("\nDigite o número desejado para conversão:");
int numero = entrada.nextInt();

System.out.printf("%d convertido em caractere equivale a \'%s\'%n", numero, Character.forDigit(numero, base));
System.out.printf("\'%s\' convertido em dígito base %d equivale a %d%n", caractere, base, Character.digit(caractere, base));

Neste exemplo, convertemos o valor numérico 14 em seu caractere correspondente no sistema hexadecimal (base 16), que é a letra ‘e’, e realizamos a conversão inversa – fornecemos o valor ‘A” em hexadecimal e o convertemos em seu valor correspondente no sistema decimal.

Anterior: A Classe Character em Java

O post Converter caracteres e dígitos com digit e forDigit, métodos da classe Character em Java apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.