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.

Todos os objetos em Java possuem um método toString que permite obter a representação em string do objeto em questão, por exemplo, para fins de exibição. Porém, os tipos primitivos (como int, float, boolean, char, etc.) não possuem esse método, pois na verdade eles não tem nenhum método (afinal, são tipos primitivos, e não classes).

Ainda assim, é possível obter a representação de string de um tipo primitivo usando um método especial pertencente à classe String: o método valueOf.

O método valueOf é um método estático que recebe um argumento de qualquer tipo e o converte em um objeto String, que pode ser então processado por métodos como printf, println ou qualquer outro que trabalhe com cadeias de caracteres.

Exemplos

Vejamos alguns exemplos.

// Declarar algumas variáveis de tipos primitivos
boolean valorBooleano = false;
int valorInteiro = 13;
char valorCaractere = 'F';
float valorFloat = 3.14f;
double valorDouble = 1.61803;

// Verificar os valores das variáveis
System.out.printf("Booleano: %s%n", String.valueOf(valorBooleano));
System.out.printf("Inteiro: %s%n", String.valueOf(valorInteiro));
System.out.printf("Caractere: %s%n", String.valueOf(valorCaractere));
System.out.printf("Float: %s%n", String.valueOf(valorFloat));
System.out.printf("Double: %s%n", String.valueOf(valorDouble));

Veja que foram retornadas as representações em string dos valores primitivos passados para o método valueOf.

É isso aí! Na próxima lição vamos apresentar a classe StringBuilder em Java, que permite realizar operações avançadas de criação e manipulação de Strings dinâmicas.
Até!

O post O método valueOf em Strings – Programação em Java apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Usamos a classe String para representação de strings (cadeias de caracteres) em Java. Esta classe possui construtores que permitem inicializar objetos do tipo String de várias formas. O exemplo a seguir ilustra quatro delas:

char[] arrayCarac = {'B', 'o', 's', 'o', 'n', ' ', 'T', 'r', 'e', 'i', 'n', 'a', 'm', 'e', 'n', 't', 'o', 's'};
String txt = new String("Fábio dos Reis");

// Quatro formas de Construtores da classe String
String tex1 = new String();
String tex2 = new String(txt);
String tex3 = new String(arrayCarac);
String tex4 = new String(arrayCarac, 6, 5);

System.out.printf("tex1 = %s%ntex2 = %s%ntex3 = %s%ntex4 = %s%n", tex1, tex2, tex3, tex4);

• No primeiro exemplo chamamos o construtor sem passar nenhum argumento. 
• No segundo exemplo, o construtor recebe um argumento, no caso uma string.
• O terceiro exemplo mostra o construtor recebendo um array de caracteres.
• O quarto exemplo mostra o construtor recebendo 5 caracteres a partir da posição 6 de um array de caracteres passado como primeiro argumento.

Métodos length, charAt e getChars

Esses métodos nos permitem obter o tamanho de uma string (seu comprimento), o caractere armazenado em uma posição específica ou ainda retornar um conjunto de caracteres de um objeto String na forma de um array de caracteres.

• Método length – Retorna o número de caracteres presentes em uma String.
• Método charAt – Retorna o caractere presente em uma posição específica da string. Este método recebe um número inteiro como argumento, e retorna o caractere que esteja armazenado na posição de índice equivalente a esse número. Lembre-se que contamos os elementos em uma String a partir da posição 0.
• método getChars – O método getChars recebe quatro argumentos: o primeiro é o valor de índice inicial a partir do qual caracteres serão copiados. O segundo é o valor de índice final + 1, indicando o último caractere a ser copiado. O array que receberá os caracteres é o terceiro argumento. Finalmente, o último argumento é o valor de índice (posição) no array a partir de onde os caracteres serão armazenados.

Vejamos exemplos da aplicação desses métodos em Java.

String string1 = "Bóson Treinamentos";
char[] arrayCar = new char[5];
System.out.printf("string1: %s", string1);

// Comprimento da string:
System.out.printf("%nComprimento da string1: %d caracteres", string1.length());

//Mostrar os caracteres da string1 em reverso com charAt
System.out.printf("%nString1 de trás pra frente: ");
for (int cont = string1.length() - 1; cont >= 0; cont--) {
  System.out.printf("%c ",string1.charAt(cont)); }

// Criar um array de caracteres a partir da String:
string1.getChars(0, 5, arrayCar, 0);
System.out.printf("%nO array de caracteres criado é: ");
for (char caractere : arrayCar) {
  System.out.print(caractere); }

Comparação de Strings em Java

É muito comum a necessidade de ter de comparar strings em uma aplicação. A classe String fornece métodos que permitem realizar comparações de diversas formas. A seguir, alguns dos métodos mais comuns de comparação de strings em Java:

• Método equals – O método equals verifica se dois objetos são iguais – mais precisamente, se eles são idênticos, retornando true caso sejam, e falso caso não sejam. A comparação é feita usando os valores inteiros Unicode de cada caractere dentro da String, o que chamamos de comparação lexicográfica. Note que isto significa que ele diferencia maiúsculas de minúsculas.
• Método equalsIgnoreCase – O método equals faz distinção de caso. Porém, se for necessário ignorar a diferença entre maiúsculas e minúsculas em uma comparação de Strings, devemos usar o método equalsIgnoreCase.
• Método compareTo – O método compareTo retorna um valor numérico dependendo do resultado da comparação. O valor 0 é retornado se as Strings forem iguais. Um número negativo é retornado se a String passada como argumento for maior que a String que invoca o método, e um número positivo é retornado se a string passada como argumento for menor que a String que o invoca. Este método também emprega comparação lexicográfica.
• Método regionMatches – Este método permite comparar partes de duas Strings. Ele emprega quatro ou cinco argumentos, como segue:
  • O primeiro argumento é o índice inicial na String que chama o método.
  • O segundo argumento é a String que será comparada.
  • O terceiro argumento é é o índice inicial na String que será comparada.
  • O quarto argumento é o número de caracteres que serão comparados.
  • Opcionalmente, podemos adicionar um outro argumento inicial para forçar o método a ignorar o caso. Para isso, o argumento inicial deve ser o valor true.
• Método startsWith – Verifica se uma String inicia com uma sequência definida de caracteres. Passamos a sequência de caracteres a comparar como argumento. Podemos passar opcionalmente um segundo argumento numérico indicando em qual posição deve se iniciar a comparação dos caracteres.
• Método endsWith – Verifica se uma String termina com uma sequência definida de caracteres. Também passamos a sequência de caracteres a comparar como argumento para o método.

Vejamos alguns exemplos de comparação de string usando esses métodos.

String tex1 = new String("Bóson"); // O objeto tex1 é uma cópia dos caracteres "Bóson"
String tex2 = "Méson";
String tex3 = "NÍVEL QUÂNTICO";
String tex4 = "Nível Quântico";
System.out.printf("tex1 = %s%ntex2 = %s%ntex3 = %s%ntex4 = %s%n%n", tex1, tex2, tex3, tex4);

// Testar igualdade de strings
if (tex1.equals("Bóson"))
  System.out.println("tex1 é igual à \"Bóson\"");
else
  System.out.println("tex1 não é igual à \"Bóson\"");

// Testar igualdade de strings, ignorando maiúsculas e minúsculas
if (tex3.equalsIgnoreCase(tex4))
  System.out.printf("%s é igual à %s se ignorarmos o caso%n", tex3, tex4);
else
  System.out.println("tex3 não é igual a tex4");

// Testar usando método compareTo
System.out.printf("%ntex1.compareTo(tex1) é %d", tex1.compareTo(tex1));
System.out.printf("%ntex1.compareTo(tex2) é %d", tex1.compareTo(tex2));
System.out.printf("%ntex2.compareTo(tex1) é %d", tex2.compareTo(tex1));
System.out.printf("%ntex3.compareTo(tex4) é %d", tex3.compareTo(tex4));
System.out.printf("%ntex4.compareTo(tex3) é %d%n%n", tex4.compareTo(tex3));

// Teste com método regionMatches (exemplo case sensitive)
if (tex3.regionMatches(0, tex4, 0, 5))
  System.out.println("Os primeiros 5 caracteres de tex3 e tex4 correspondem");
else
  System.out.println("Os primeiros 5 caracteres de tex3 e tex4 não correspondem");

// Teste com método regionMatches (exemplo ignorando caso)
if (tex3.regionMatches(true, 0, tex4, 0, 5))
  System.out.println("Os primeiros 5 caracteres de tex3 e tex4 correspondem, ignorando o caso");
else
  System.out.println("Os primeiros 5 caracteres de tex3 e tex4 não correspondem");

// Testar igualdade com o operador ==
if ( ) // retorna falso, pois não são o mesmo objeto
  System.out.println("tex1 é igual a \"Bóson\"");
else
  System.out.println("tex1 não é igual a \"Bóson\"");

Perceba que não é correto usar o operador de comparação == para comparar dois objetos String.

Vejamos agora exemplos dos métodos startsWith e endsWith em Strings.

String meuTexto = new String("Bóson Treinamentos");
// Testar se a String inicia com Bó
if (meuTexto.startsWith("Bó")) {
  System.out.println("A String inicia com Bó");
}

// Testar se a String inicia com Bo (sem acento):
if (meuTexto.startsWith("Bo")) {
  System.out.println("A String inicia com Bo");
}
else {
  System.out.println("A String não inicia com Bo");
}

// Testar se a String possui as letras son (a partir do 3º caractere):
if (meuTexto.startsWith("son", 2)) {
  System.out.println("Sequência \"son\" está na posição indicada");
}
else {
  System.out.println("Sequência \"son\" não está na posição indicada");
}

// Testar se a String termina com a letra o:
if (meuTexto.endsWith("o")) {
  System.out.println("A String termina com a letra o");
}
else {
  System.out.println("A String não termina com a letra o");
}

Na próxima lição vamos mostrar mais métodos que podem ser aplicados na manipulação de Strings em Java.

O post Programação em Java – A Classe String – Introdução apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Programação Orientada a Objetos – POO (Object-Oriented Programming – OOP) é um paradigma de programação que usa tipos de dados personalizados. Em vez de operar apenas com tipos de dados primitivos, podemos construir novos tipos de dados, conforme nossa necessidade.

Esses novos tipos de dados, que chamamos de classes, podem conter estruturas semelhantes a funções, denominadas métodos, e variáveis internas, chamadas de atributos. As classes dão origem a objetos, em um processo denominado instanciação.

Os objetos são os “blocos de construção” de software na OO.

Vantagens da Orientação a Objetos

• Fornece uma estrutura modular para a construção de programas
• Objetos podem ser reutilizados em aplicações diferentes
• O software se torna mais fácil de manter
• O desenvolvimento é mais rápido, devido ao reuso de código
• Encapsulamento: não é necessário conhecer a implementação interna de um objeto para poder usá-lo

Objeto

Trata-se de uma ocorrência específica de uma classe; é uma “instância de classe”.

Os objetos são a base da OO (Orientação a Objetos).

Os objetos representam entidades do mundo real, como aviões, pessoas, contas correntes, etc., mas também podem representar outros conceitos, como gráficos (círculos, quadrados, cones, esferas, etc.)

Um objeto possui características próprias (atributos) e executa determinadas ações (métodos), sendo esses atributos e métodos provenientes da classe que origina o objeto.

Abstração

Abstrair significa selecionar aspectos específicos de um problema a ser analisado, deixando de lado outros aspectos. É a  representação de uma entidade do mundo real na forma de idéias.

As entidades abstraídas podem se comunicar entre si, por meio da troca de Mensagens.

De acordo com o autor Correia (2006):

“Pelo princípio da abstração, nós isolamos os objetos que queremos representar do ambiente complexo em que se situam, e nesses objetos representamos somente as características que são relevantes para o problema em questão”.

Mensagens

Os objetos se comunicam a partir da troca de mensagens.

Uma mensagem é um sinal enviado de um objeto a outro, o qual requisita um serviço, usando uma operação programada no objeto chamado. Por exemplo, para que um objeto execute um método, é necessário enviar a este objeto uma mensagem solicitando a execução do método desejado.

As mensagens somente ocorrem entre objetos que possuem uma Associação.

As mensagens também são programadas. Quando uma mensagem é recebida, uma operação é invocada no objeto chamado.

Há vários formatos de mensagens: procedures (subs e functions), passagem de sinais entre threads, acionamento de eventos, etc.

O que são Classes

Uma Classe é uma coleção de objetos que são descritos com os mesmos atributos e as mesmas operações. Uma classe representa uma ideia ou conceito e classifica objetos que tenham propriedades similares.

As classes são os blocos de construção mais importantes dos sistemas orientados a objetos, e devem possuir responsabilidades bem definidas dentro da aplicação.

Uma classe é um tipo personalizado de dados.

Desta forma, uma classe é um tipo abstrato de dados, um “molde” para a criação de objetos. Cada classe criada se torna um novo tipo disponível para declarar variáveis e criar objetos

Por convenção, começamos o nome de uma classe com letra maiúscula, e capitalizamos cada palavra subsequente que o compuser.

As classes representam os blocos de construção mais importantes dos sistemas orientados a objetos, e devem possuir responsabilidades bem definidas dentro da aplicação.

Uma classe é como se fosse um tipo abstrato de dados, um “molde” para a criação de objetos.

Um objeto é, portanto, um “Instância de uma Classe”

As classes possuem atributos e métodos.  Atributos são características da classe, que são comuns a todos os objetos derivados, e que podem apresentar valores diversos. Já os Métodos são as operações possíveis em uma classe (nos objetos instanciados a partir dela).

Atributo de Classe

Ou Propriedade: Característica particular de uma ocorrência de uma classe, como por exemplo o nome e a idade de uma pessoa.

Existem dois tipos principais de propriedades:

• Estáticas: Mantém o mesmo valor durante toda a sua existência. Por exemplo, a data de nascimento de uma pessoa é uma propriedade estática, pois mantém o mesmo valor durante toda a existência do objeto instanciado.
• Dinâmicas: Podem ter valores que variam com o passar do tempo. A idade de uma pessoa pode ser considerada um atributo dinâmico, pois pode variar ao longo do tempo.

Método

É a lógica contida em uma classe para atribuir-lhe comportamentos. São as funções e procedimentos contidos na classe.

O ato de invocar um método é a passagem de mensagens para o objeto.

Toda classe possui um método especial chamado de método construtor, que inicializa o objeto instanciado.

As classes também usam métodos destruidores para finalizar os objetos após seu uso.

Um método é uma sequência de declarações (comandos) que possui um nome de identificação. É similar a uma função ou procedimento.

Um método possui um nome e um corpo onde ficam os comandos que serão executados quando o método for chamado, e também podem receber dados para processamento (parâmetros) e retornar informações.

Os métodos são a forma principal de passagem de mensagens entre objetos. Um método deve executar sempre uma operação única. Os métodos também precisam ter um tipo de retorno, que pode ser um tipo de valor, de referência ou ainda void (não retornam valor).

Classe – Notação UML para representação

A seguir temos a forma padrão para representação de uma classe usando um diagrama de classes UML:

Instância de Classe

É o objeto, uma ocorrência específica de uma classe.

As classes originam instâncias sob requisição, no processo denominado Instanciação. O projetista / analista cria a classe. A classe é então usada para criar objetos em tempo de execução.

Veja a seguir um exemplo de criação de classe na linguagem C#. É declarado um atributo da classe Caixa – lado – e um método – Volume():

Herança

Herança, em orientação a objetos, é a capacidade de um novo objeto tomar atributos e operações de um objeto existente.

Assim, podemos criar classes mais complexas sem que precisemos repetir código.

Aqui, a palavra-chave é Reuso de código, e é uma das metas a se atingir ao desenvolver software. O reuso permite reduzir o esforço dispendido no desenvolvimento de software ao reaproveitarmos códigos de uma classe na criação de outras classes.

A Herança é, portanto,  um conceito extremamente importante em Orientação a Objetos.

Usamos a herança, por exemplo, para evitar repetição ao definirmos classes com características em comum e que são relacionadas entre si.

A herança é um relacionamento entre classes, que permite que uma classe “adquira” os membros (atributos e métodos) de outra classe.

Um exemplo clássico de herança seria a classificação de mamíferos no reino animal.

Homens, Baleias e Gatos são mamíferos, que compartilham muitas características entre si, mas claramente possuem atributos que os diferem uns dos outros.

Como podemos modelar Baleias, Gatos e Humanos em um software?

Podemos criar classes distintas para cada animal, mas essas classes teriam muitos comportamentos (“métodos”) em comum entre eles, como Respirar, Mamar e Reproduzir-se, o que ocasionaria repetição desnecessária de código.

Usamos então Herança para resolver esse problema. Podemos criar uma classe chamada Mamífero que possua as características comuns a todos os animais mamíferos, e então criar as classes Humano, Baleia e Gato herdando essas funcionalidades e também implementando as funcionalidades específicas de cada animal, como Falar, Nadar e Miar.

O quadro a seguir mostra duas classes, Humano e Gato, que herdam os atributos e métodos da superclasse Mamífero, e implementam seus próprios atributos e métodos adicionais: atributos nome e sobrenome e métodos andar() e falar() para a classe Humano, e os atributos raça e nome e métodos andar() e miar() para a classe Gato:

Encapsulamento

Encapsulamento é a combinação de atributos e operações dentro de uma classe, deixando visível apenas o que é necessário para a comunicação entre dois objetos, como por exemplo alguns detalhes da implementação ou ainda a lógica de um método.

O encapsulamento permite ocultar a complexidade do código. Não é necessário entender como a operação funciona para poder utilizá-la. Um exemplo clássico é o de um motorista conduzindo um veículo. O motorista não precisa saber exatamente como um motor funciona internamente para poder dirigir o automóvel – o detalhes da “implementação” do motor ficam ocultos do motorista.

O encapsulamento protege os dados, permitindo o acesso a eles apenas a partir de métodos específicos e autorizados.

Desta forma, os objetos encapsulados podem ser comparados uma caixa preta: conhecemos  asua interface externa, porém não precisamos nos preocupar com o que acontece internamente na caixa.

Encapsulamento – Níveis de Acesso

Há três níveis principais de acesso dos objetos:

• Público
• Privado
• Protegido

Vamos discutir em mais detalhes esses níveis de acesso em uma lição especial sobre o assunto.

Polimorfismo

Uma operação de um objeto qualquer pode assumir vários comportamentos dependendo da chamada recebida, tratando e devolvendo respostas ao chamador.

Poli = Muitos; Morphos = Formas. Portanto, Polimorfismo = “múltiplas formas”.

Portanto, o polimorfismo ocorre quando um objeto tem um comportamento diferente para uma mesma ação. Por exemplo, usando nosso exemplo de classes de animais, nas classes Gato e Humano existe um comportamento (método) em comum: Andar. Porém, cada uma dessas classes implementa o método Andar de forma diferente – os gatos andam em quatro patas, enquanto os humanos andam em duas. Ambos podem percorrer a mesma distância andando, ou seja, executando o método andar, mas o farão de forma diferente entre si.

Então, dependendo de como um método é invocado, seu comportamento será diferente.

Neste artigo publicamos uma pequena introdução à Orientação a Objetos. Nos próximos artigos desta série vamos nos aprofundar nesses assuntos, e apresentar muitos outros conceitos relativos a esse tópico.

O post Conceitos de Programação Orientada a Objetos apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.