Switch Case (Default e Break) em Java

A estrutura de decisão switch case é uma alternativa a estrutura if then else que permite que uma determinada variável seja testada quando a sua igualdade a uma série de valores, sendo cada um desses valores um caso (do inglês case) a qual a variável em teste pode ser comutada (switch).

O switch permite que o fluxo de execução do programa selecione entre uma série de alternativas (case´s), sendo que em determinadas situações é mais eficiente e legível do que uma série de estruturas if aninhadas. A sintaxe do switch case é a seguinte:

   1 switch (expressão)
   2 {
   3     case constante1 :
   4         // declarações executadas
   5         break; // opcional
   6     case constante2 :
   7         // declarações executadas
   8         break; // opcional
   9     case constante3 :
  10         // declarações executadas
  11         break; // opcional
  12     .
  13     .   // quantos casos forem necessários
  14     .
  15     default : // opcional
  16         // declarações executadas caso nenhum
  17         // case anterior seja verdadeiro
  18 }

A declaração switch case em Java funciona com os seguintes tipos de dados:
  • tipos primitivos de dados byte, short, char e int;
  • a classe String (a partir do Java JDK 7);
  • os tipos de dados enumerados (enum);
  • as classes wrapper dos tipos primitivos: Byte, Short, Character e Integer.

Artigo em construção.

Referências:
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html
http://www.tutorialspoint.com/java/java_decision_making.htm

Algoritmo para calcular números primos em Java

Um exercício comum aos iniciantes no estudo da linguagem de programação Java é a resolução de um algoritmo para calcular números primos. Esse é um algoritmo solicitado também em avaliações de desempenho, como entrevistas/seleções para vagas de emprego com Java.

Definição, histórico e importância dos números primos

Número primo é definido como todo número que é divisível somente por si mesmo e pelo número 1, possuindo somente dois fatores sendo estes 1 e ele mesmo. Pela definição o números 0 e 1 não podem ser considerados primos, e uma importante observação é a que o único número par e primo é o 2, pois todos os outros pares são divisíveis por 2 além de si mesmo e 1.

Qualquer número com outros divisores é chamado de número composto, sendo possível ser escrito como uma série de fatores primos (fatoração). Não existe nenhuma fórmula prática que diga de forma imediata se um número é primo ou composto, havendo a necessidade de se verificar isso através de um algoritmo.

Os números primos são conhecidos e estudados desde os primórdios dos estudos matemáticos na Grécia antiga: Euclides, um professor, matemático e escritor grande contribuidor da geometria (o "pai da geometria") já comprovou em 300 a.C. que existem infinitos números primos.

Outro estudioso grego muito importante na história dos números primos foi Eratóstenes, pois desenvolveu o primeiro algoritmo conhecido para gerar tabelas de números primos: o crivo de Eratóstenes.

Atualmente a primalidade é responsável pelos fundamentos teóricos da criptografia avançada utilizada na sociedade, como codificação de sistemas bancários, transações online, armazenamento seguro de dados e demais áreas que precisem de dados protegidos. Um exemplo é o algoritmo RSA, que usa números primos grandes para gerar suas chaves de cifragem.

Portanto os números primos são extremamente importantes na vida das pessoas nos dias de hoje e continuam sendo foco de estudo acadêmico constante em busca de maneiras melhores de se encontrar números primos de grande magnitude.

Números primos em Java

Algoritmo básico para determinar números primos

O seguinte algoritmo básico do exercício resolvido ilustra uma solução que imprime os números primos entre 2 e 100. Ele é básico pois têm somente fins educacionais, não é nada otimizado e não serve para calcular números com muitos dígitos, sendo muito lento nesses casos.

Nesse algoritmo é usada uma variável booleana (primo, linha 5) que define um número como sendo primo (linha 8) até que se prove o contrário (linha 13) testando todas as divisões possíveis desde 2 até o número-1 (laço for interno, linha 9).

Essa verificação da possibilidade de divisão é feita através do resto da divisão inteira com o operador módulo (%, linha 11). Caso o número seja divisível (resto 0), então o número não é primo e o laço for é encerrado (linhas 13 e 14). Por fim, caso o número tenha sido provado como primo, é impresso na tela (linhas 17-20).

   1 public class Primos {
   2     public static void main(String args[])
   3     {
   4         int numero, divisor;
   5         boolean primo;
   6         for (numero = 2; numero <= 100; numero++)
   7         {
   8             primo = true;
   9             for (divisor = 2; divisor < numero; divisor++)
  10             {
  11                 if (numero % divisor == 0)
  12                 {
  13                     primo = false;
  14                     break;
  15                 }
  16             }
  17             if (primo)
  18             {
  19                 System.out.println(numero);
  20             }
  21         }
  22     }
  23 }

Download Primos.java

Apesar de perfeitamente funcional o algoritmo acima não é otimizado, o que é necessário quando se quer calcular se números muito grandes são primos com uma performance aceitável.

Otimizando a verificação de primalidade

Algumas observações matemáticas permitem a resolução do exercício de verificação da primalidade de uma maneira mais rápida/otimizada, eliminando a verificação da divisibilidade por um conjunto grande de números cuja possibilidade de divisão já é conhecida previamente.

A observação mais simples, porém nem tão óbvia em uma primeira abordagem, é que o único número par e primo é o 2, pois todos os outros pares são divisíveis por 2 (critérios de divisibilidade) além de 1 e si mesmo. Portanto podemos alterar a linha 6 do algoritmo anterior para checar somente os números ímpares a partir do número 3 (de dois em dois), e imprimir o número 2 previamente sem verificação.

Outra observação é a de que nenhum número tem divisor além de si mesmo que seja maior do que sua raiz quadrada. Então podemos alterar a repetição for interna (linha 9 no algoritmo anterior) para checar somente até a raiz quadrada do número evitando checar toda a faixa até o próprio número.

Para definir esse limite de verificação redundante, é usado o método estático sqrt da classe Math, como demonstrado no algoritmo a seguir devidamente alterado.

   1 public class PrimosSQRT {
   2     public static void main(String args[])
   3     {
   4         int numero, divisor;
   5         boolean primo;
   6         System.out.print("2 ");
   7         for (numero = 3; numero <= 100; numero += 2)
   8         {
   9             primo = true;
  10             for (divisor = 2; divisor <= Math.sqrt(numero); divisor++)
  11             {
  12                 if (numero % divisor == 0)
  13                 {
  14                     primo = false;
  15                     break;
  16                 }
  17             }
  18             if (primo)
  19             {
  20                 System.out.print(numero+" ");
  21             }
  22         }
  23         System.out.println();
  24     }
  25 }

Download PrimosSQRT.java

Referências:
Número Primo - Wikipédia

Como instalar o JDK 8 no Windows XP

Caso tenha se deparado com a mensagem de erro "The procedure entry point RegDeleteKeyExA could not be located in the dynamic link library ADVAPI32.dll", saiba que não é possível instalar o JDK 8 no Windows XP através do instalador automático da Oracle.

Isso devido ao fato de que a partir de 08 de abril de 2014 a Microsoft parou de dar suporte ao Windows XP e a Oracle parou de suportar o Java na plataforma também, apesar de ainda ser um sistema operacional muito utilizado. O anúncio oficial está em uma nota no link http://www.oracle.com/technetwork/java/javase/config-417990.html.

Existe uma solução para os desenvolvedores Java que trabalham com o Windows XP: os binários do JDK 8 funcionam perfeitamente no sistema porém o kit de desenvolvimento da Oracle tem que ser instalado de forma manual, conforme explicado abaixo nesse tutorial.

Java JDK 8 no Windows XP
Após baixar o executável instalador (.EXE) do kit de desenvolvimento Java (JDK) no site da Oracle, extraia o conteúdo dele para um diretório/pasta específico tal qual jdk-8u11-windows-i586/. Isso pode ser feito com algum utilitário compactador de arquivos compatível com a compressão usada no instalador da Oracle. Um deles é o 7-Zip, cujo download free está disponível em http://www.7-zip.org/.

Com o 7-Zip isso é feito clicando-se com o botão direito do mouse no instalador do JDK e escolhendo a opção "Extract To jdk-8u11-windows-i586/" dentro do sub-menu do 7-Zip. O nome do arquivo .EXE do instalador e da respectiva pasta varia de acordo com a versão do kit Java, nesse caso trata-se da release 11 do JDK 8.

Dentro dessa pasta recém criada vemos que foi extraído um arquivo .ZIP chamado tools.zip, que contém as ferramentas do compilador Java. Faça a descompactação desse arquivo também, pode ser nessa pasta mesmo usando a opção "Extract Here" do 7-Zip.

Agora deve ser feita a descompressão dos pacotes da biblioteca Java. Para isso use o arquivo batch unpack.bat. Faça o download do unpack.bat e coloque-o dentro da pasta jre/bin/ que foi criada dentro da pasta jdk-8u11-windows-i586/. Importante: o unpack.bat só funciona dentro da pasta bin, pois faz uso do utilitário unpack200.exe do Java.

Execute o arquivo batch unpack.bat e observe que ele irá executar os seguintes comandos em uma janela do shell (Prompt de Comando) do Windows XP, descompactando os arquivos .JAR dos pacotes Java:

unpack200 ..\lib\charsets.pack ..\lib\charsets.jar
unpack200 ..\lib\deploy.pack ..\lib\deploy.jar
unpack200 ..\lib\javaws.pack ..\lib\javaws.jar
unpack200 ..\lib\jsse.pack ..\lib\jsse.jar
unpack200 ..\lib\plugin.pack ..\lib\plugin.jar
unpack200 ..\lib\rt.pack ..\lib\rt.jar
unpack200 ..\lib\ext\jfxrt.pack ..\lib\ext\jfxrt.jar
unpack200 ..\lib\ext\localedata.pack ..\lib\ext\localedata.jar
unpack200 ..\..\lib\tools.pack ..\..\lib\tools.jar

Resolvido, só falta definir a variável de ambiente PATH do Windows XP para apontar para a pasta do JDK recém criada. Particularmente prefiro mover essa pasta para o diretório raíz do sistema de arquivos para facilitar o uso dentro dos editores/IDE´s Java. A definição da variável PATH no XP é feita em Iniciar > Configurações > Sistema - Avançado - Variáveis de Ambiente - Path.

Dependendo do editor/IDE ou outra forma que será usada para compilar os aplicativos Java pode ser necessário definir outras variáveis de ambiente tais quais CLASSPATH ou JAVA_HOME. Informações mais detalhadas de como definir a variável de ambiente PATH para funcionamento do Java podem ser conferidas no site da Oracle:  http://docs.oracle.com/javase/tutorial/essential/environment/paths.html.

É possível conferir se o JDK foi instalado corretamente abrindo um prompt de comando do Windows e digitando: javac -version, que deve mostrar a mensagem javac 1.8.0_11, no caso da release 11 do kit de desenvolvimento Java 8.

Referências:
http://www.kriblog.com/j2se/general/the-procedure-entry-point-regdeletekeyexa-could-not-be-located-in-the-dynamic-link-library-advapi32.dll.html