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.

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.

Para a manipulação de strings em Java existe a classe String, que já estudamos em outra lição. Porém, ao trabalharmos com caracteres individuais é muito comum usar o tipo primitivo char. Porém, o tipo char, justamente por ser um tipo primitivo, não possui métodos especializados para a manipulação de dados do tipo. Mas isso não significa que não seja possível usar métodos específicos em tipos de caractere – basta para isso manipular o tipo com uma classe wrapper. 

A classe Character é uma classe wrapper, ou seja, um classe que embrulha / empacota valores primitivos, permitindo que esses valores sejam tratados como se fossem objetos.

A maior parte dos métodos da classe Character são métodos estáticos, empregados no processamento de caracteres individuais. Os métodos recebem um ou mais caracteres como argumento e realizam testes ou manipulação dos caracteres.

Também é possível inicializar um objeto Character, pois esta classe possui um método construtor que recebe um caractere como argumento para inicializar o objeto.

Exemplos

Vejamos alguns exemplos de uso da classe Character em Java.

Scanner entrada = new Scanner(System.in); // Não esqueça de importar o Scanner no início do código!
System.out.println("Digite um caractere qualquer e pressione Enter:");
String str = entrada.next();
char c = str.charAt(0); // Obter o caractere digitado

// Usando a classe Character para obter informações:
System.out.printf("é definido? %b%n", Character.isDefined(c));
System.out.printf("é um dígito? %b%n", Character.isDigit(c));
System.out.printf("é uma letra? %b%n", Character.isLetter(c));
System.out.printf("é letra ou dígito? %b%n", Character.isLetterOrDigit(c));
System.out.printf("Maiúsculo? %b%n", Character.isUpperCase(c));
System.out.printf("Minúsculo? %b%n", Character.isLowerCase(c));
System.out.printf("Converter para maiúsculo: %s%n", Character.toUpperCase(c));
System.out.printf("Converter para minúsculo: %s%n", Character.toLowerCase(c));

Os métodos usados nos exemplos foram os seguintes:

• isDefined – Determina se o caractere passado como argumento está definido no conjunto de caracteres Unicode. Se estiver, o método retorna true; caso contrário, retorna false.
• isDigit – Determina se o caractere é um dígito (número) definido no Unicode.
• isLetter – Determina se o caractere é uma letra do alfabeto.
• isLetterOrDigit – Determina se o caractere é uma letra ou um dígito numérico.
• isUpperCase – Determina se o caractere é uma letra maiúscula.
• isLowerCase – Determina se o caractere é uma letra minúscula.
• toUpperCase – Converte o caractere para maiúscula.
• toLowerCase – Converte o caractere para minúscula.

Na próxima lição veremos mais alguns métodos importantes da classe Character, como os métodos digit e forDigit, por exemplo.

Até!

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