Com a classe Scanner, ficou mais fácil manipular a entrada de dados pelo console. A seguir, apresentamos as duas formas mais comuns de manipular dados vindos do dispositivo de entrada padrão (teclado).

Entrada de dados do tipo "String":
// 1 º passo: Importar a classe Scanner
import java.util.Scanner;

// 2 º Passo: Criar um objeto Scanner
Scanner input = new Scanner (System.in);

// 3 º passo: Atribuir uma entrada a uma variável
String name = input.nextLine ();
Entrada de dados tipo "numérico" :
// 1 º passo: Importar a classe Scanner
import java.util.Scanner;

// 2 º Passo: Criar um objeto Scanner
Scanner input = new Scanner (System.in);

// 3 º passo: Atribuir uma entrada a uma variável
int value = input.nextInt ();
// ou
double value = input.nextDouble ();
Além de ler dados a partir do teclado, podemos ler dados diretamente de um arquivo texto. Em breve, traremos um post falando sobre esse tipo de operação que pode ser realizada com a classe Scanner.

@Ojavaman

Posted on sábado, novembro 02, 2013 by Unknown

No comments


Em muitas situações durante a programação, precisamos implementar programas que executam algum comando repetidamente. Por isso, é importante conhecer comandos de repetição, como é o caso do "for".

Sintaxe:
for(p1; p2; p3) {...}

p1: É onde declaramos e inicializamos o contador.
p2: É onde estabelecemos nossa condição de continuidade do loop.
p3: É onde alteramos o valor do contador.

Vamos criar um programa que escreve na tela os valores de 1 à 10.
public class Loops {
  public static void main(String[] args){

    for(int i = 1; i <= 10; i++) {
      System.out.println(i);

    }
  }
}
Explicação:
No programa acima, declaramos uma variável "i" e inicializamos com o valor 1 através do comando "int i = 1".
Em seguida, estabelecemos que o loop seria executado enquanto a variável "i" guardasse um valor menor ou igual a 10, através do comando "i <= 10".
Finalizamos incrementando o valor armazenado em "i" com o comando "i++", que é equivalente ao comando "i = i + 1".

Agora, vamos implementar algo um pouco mais interessante. Vamos imaginar que precisamos criar um loop para somar todos os elementos de um array (ver explicação sobre arrays aqui).

O código é o seguinte:
public class SomaValores {
  public static void main(String[] args) {

    // declaração e inicialização do vetor
    int[] vet = {1,2,3,4,5,6,7,8,9,10};
    // declaração da variável que armazenará a soma dos elementos
    int soma = 0;
    for(int i = 0; i < 10; i++) {
      soma = soma + vet[i];
    }
    System.out.println(soma);
  }
} 
Na implementação acima, declaramos um array com 10 posições, que são indexadas (numeradas) de 0 a 9. Por isso, inicializamos a variável "i" com o valor 0, e estabelecemos que o corpo do loop seria executado enquanto o valor armazenado em "i" fosse menor do que 10. Concluimos nossa implementação imprimindo o valor da variável "soma" no console.

See you later!
@ojavaman

Posted on sábado, outubro 19, 2013 by Unknown

No comments

Desafio 2:
Converter um inteiro de decimal para binário

Deixem soluções nos comentários
@OjavaMan

Posted on sábado, outubro 19, 2013 by Unknown

1 comment

Vamos começar com um desafio simples:
Inverter um array de inteiros usando recursividade
Possíveis assinaturas do método:
public void inverte(int []vet, int n) // n é o tamanho do vetor
{...}
public void inverte(int[] vet, int i, int j) // i e j são os limites do vetor
{...}

Deixem soluções nos comentários.

Posted on sexta-feira, outubro 18, 2013 by Unknown

1 comment


Dando continuidade com posts sobre números binários, com o Java 7 é possível representar valores literais em binário. Para isso, basta utilizar o prefixo 0b antes do valor em binário, ou seja, para representar o número 10 basta fazer:
int binario = 0b1010;
Observem que o número binário (1010) é a representação do valor decimal 10. A construção a seguir é válida:
int binario = 0b1010;
if(binario == 10){...}

Posted on sexta-feira, outubro 18, 2013 by Unknown

No comments


Em Java, assim como em outras linguagens, podemos manipular os bits armazenados nas variáveis. Esse tipo de abordagem é importante quando queremos que nosso programa realize operações da forma mais eficiente possível.
Operações matemáticas podem ser realizadas utilizando os chamados operadores bit-a-bit. Com estes operadores, nós de fato manipulamos cada um do conjunto de bits que representam um dado valor.

Para exemplificar, vamos analisar a forma como Java trata variáveis do tipo char: Um variável declarda como char, é na verdade um inteiro que vai de 0 a 65538, ou seja, 2^16. Por possuir apenas 16 bits, uma variável do tipo char só pode armazenar caracteres da tabela ASCII. Por exemplo:
char a = 65; // 65 é o código ASCII para o caractere 'A'
char b = 66; // 66 é o código ASCII para o caractere 'B'
As representações binárias dos valores 65 e 66 são respectivamente 10000001 e 10000010.

Dicas e truques:

1) Verificando a paridade de um número
Podemos proceder da forma convencional e verificar se o resto da divisão de um número por 2 é zero ou um. Caso o resto seja zero, o número é par, caso contrário, o número é ímpar.
int n = 10;
boolean isEven(int n){
  return (n % 2) == 0;
}
Um forma mais eficiente de verificar a paridade de um número é através do operador &. Sabendo que em números pares o bit menos significativo é zero e em números ímpares é um, podemos saber a paridade do número fazendo:
int n = 10; // 1010 é a representação binária do número 10
boolean isEven(int n){
  return (n & 1) == 0;
}
Ou seja, n & 1 faz a operação 1010 & 1, como 0 & 1 é igual a zero, sabemos que o número é par.

2) Multiplicando um número por 2
Para dobrar o valor de uma variável, podemos usar o operador << (left-shift) e deslocar todos os bits uma posição para a esquerda. Ou seja:
int n = 11;
n = n << 1; // n agora vale 22 

3) Dividindo um número por 2
Para dividir por 2 o valor armazenado em uma variável, podemos usar o operador >> (right-shift)
int n = 10;
n = n >> 1; // n agora vale 5
4) Testando bits
Podemos verificar cada um dos bits que fazem parte da representação binária de um número. Para isso, usamos uma máscara, que inicialmente será 1. Voltando ao exemplo da variável char, vamos verificar quantos bits são iguais a 1 na representação binária do caractere 'A'.
char a = 'A';
char mask = 1;
int n = 0; // armazena a quantidade de 1's encontrados na representação binária 
while(a > 0){
  if(a & mask == 1)
    n++;
  a = (char) (a >> 1);
}
Em breve traremos mais exemplos de manipulação de bits. Continuem acompanhando nosso blog.
Para uma abordagem mais teórica sobre a conversão de números entre bases numéricas acessem o InductionCode e confiram os posts clicando aqui.
@Ojavaman

Posted on quinta-feira, outubro 17, 2013 by Unknown

No comments



Strings em Java são classes especiais que representam cadeias de caracteres alfanuméricos.
A declaração, seguida ou não de inicialização, é feita conforme o exemplo:
String nome;
String flag = "fim";
Uma vez que as variáveis do tipo String são na realidade objetos, a comparação entre elas não pode ser feita usando o operador "==".
Métodos:
int length(): retorna a quantidade de elementos da string.
String nome = "bicicleta";
int i = nome.length(); // retorna 9
Operador "+" é usado para realizar a concatenação de strings.
System.out.println("O vencedor é" + vencedor);
boolean equals(String): retorna o resultado da comparação do conteúdo de duas Strings.
String S1 = "Fim";
String S2 = "Fim";
S1.equals(S2) // retorna true.
Um dos principais objetivos de uma boa linguagem de programação é fazer uso eficiente de memória, e com Java não poderia ser diferente. Por isso, poderíamos pensar que a comparação "s1 == s2" retorna false, mas não é bem assim.
A JVM possui uma área de memória conhecida como "pool", e toda vez que o compilador encontra uma nova string literal, ele verifica se essa string já existe no "pool". Se a string já existir, a referência para a nova string é direcionada para a string existente, fazendo com que um novo objeto do tipo String não seja criado.

See you later!

Posted on quarta-feira, outubro 16, 2013 by Unknown

2 comments


 Neste post, vamos aprender, em dois passos, a compilar e executar um programa java direto na linha de comando. Quando estamos programando em ide's como Eclipse ou NetBeans esses passos são executados internamente e nós nem percebemos.

Para compilar e executar o nosso programa, executaremos dois comandos:
Primeiro vamos compilar a nossa classe java com o compilador javac:
javac MyClass.java
Agora vamos chamar a maquina virtual java (JVM), para que ela possa executar os bytecodes gerados durante a compilação:
java MyClass
Até que não foi tão difícil. =D
See you later!!!

Posted on quarta-feira, outubro 16, 2013 by Unknown

No comments