Aprenda Java

Tudo sobre Java Parte 2

Tipos Primitivos e Manipulação de Dados

Existem três maneiras básicas para fazer declarações de tipos primitivos no Java. Pra atribuir uma idade, por exemplo, fazemos dessas formas:

Maneira mais simples, com a declaração no início:


int idade = 3;
float sal = 1825.54f;
char letra = 'G';
boolean casado = false;

PS: Observe que números reais tem que ter o f no final, em Java. O char não permite mais de uma letra e tem que usar aspas simples.

Declaração especificando com typecast (para considerar o número como inteiro, número com ponto como real e assim por diante):


int idade = (int)3;
float sal = (float)1825.54;
char letra = (char)'G';
boolean casado = (boolean)false;

Usando classes (nesse caso eles são objetos, não variáveis comuns):


Integer idade = new Integer(3);
Float sal = new Float(1825.54);
Character letra = new Character('G');
Boolean casado = new Boolean(false);

Na última, Integer, Float, Character e Boolean não são tipos, são classes. O new indica que o conteúdo não é uma variável, e sim a criação de um objeto. O número será considerado inteiro e colocado dentro do objeto, o mesmo acontece com as outras classes. O nome que se dá a esse tipo de classe é Wrapper Class (wrapper é invólucro).

PS: Evite de criar variáveis com Classes usando o new desnecessariamente, pois caso ele estivesse num loop, ele criará novas instâncias do mesmo objeto em cada repetição, que deixará o programa pesado. Podemos usar a classe invólucro e iniciar como um tipo primitivo comum nesse caso, dessa forma:


Integer idade = 3;
Float sal = 1825.54f;
Character letra = 'G';
Boolean casado = false;

Veja uma tabela com os tipos suportados pelo Java:

Família	Tipo Primitivo	Classe Invólucro	Tamanho	Exemplo
Lógico	boolean	Boolean	1 bit	true
Literais	char	Character	1 byte	'A'
Literais	-	String	1 byte por letra	"Java"
Inteiros	byte	Byte	1 byte	127
	short	Short	2 bytes	32767
	int	Integer	4 bytes	2147483
	long	Long	8 bytes	2⁶³
Reais	float	Float	4 bytes	3.4e⁺³⁸
Reais	double	Double	8 bytes	1.8e⁺³⁰⁸

Podem ver que, para guardar strings, não usamos tipos, e sim a classe String, ela não tem limite de tamanho e tem que usar aspas duplas, por isso elas são consideradas objetos. Em tipo byte e classe Byte não dá pra armazenar números maiores que 127, na tabela acima, inclusive, estão os números máximos de todos. Esses vários tipos primitivos existem para o caso de criar aplicativos para pequenos aparelhos (como um pequeno relógio em Java) ou aplicativos maiores, para economizar dados, se preciso.

PS: As classes invólucros devem ser utilizadas em casos como parâmetros de entidades genéricas, quando precisamos de métodos estáticos dessas classes e principalmente quando precisamos atribuir null à variável, já que, por elas serem classes, permitem valores nulos, coisas que os tipos primitivos comuns não permitem.

Agora vamos mostrar saída de dados usando os tipos primitivos, usando o simples método, faça uma aplicação Java nova, assim:


public static void main(String[] args) {
    float nota = 8.5f;
    System.out.println("A nota é " + nota);
}

Também podemos usar o comando System.out.printf para formatar números, usando o %f, dessa forma:


System.out.printf("A nota é %f\n", nota);

E também podemos formatar a quantidade de números decimais usando a máscara com o número de casas e a letra f, dessa forma:


System.out.printf("A nota é %.2f\n", nota);

PS: Esse uso da porcentagem para formatação se chama máscara de formatação. E note também que nesse caso deve se usar vírgulas ao invés de mais, porque não é concatenação e sim formatação. E note que o \n é para quebrar a linha, essas já são chamadas de sequências de escape e podem ser usadas em qualquer situação. Todas são originárias da linguagem C e são usadas em várias outras descendentes, como o próprio Java.

As máscaras também podem ser usadas em outros casos, como nesse:


public static void main(String[] args) {
    String nome = "Gustavo";
    float nota = 8.5f;
    System.out.printf("A nota de %s é %.1f\n", nome, nota);
}

Podemos utilizar format no lugar de printf, dessa forma:


System.out.format("A nota de %s é %.1f\n", nome, nota);

Existe também o String.format(), que funciona do mesmo modo, ele é usado dentro de métodos de componentes Swing, JavaFX, JOptionPane e outros.

Essas são algumas das máscaras aceitas em Java:

Máscara	Significado
`%d`	Valor decimal (positivo ou negativo)
`%u`	Valor decimal sem sinal (só positivo)
`%f`	Valor real
`%s`	String
`%c`	Caractere único
`%b`	Valor booleano

PS: Em qualquer situação de uso de Strings, para transformar os caracteres em maiúsculos, usamos o método toUpperCase() do objeto String, da mesma forma para minúsculos usamos o toLowerCase(), como por exemplo:


String frase = "Um Texto Qualquer";

System.out.println("Em minúsculas: " + frase.toLowerCase());
System.out.println("Em maiúsculas: " + frase.toUpperCase());

Para fazer o mesmo com char, use os métodos do mesmo nome da classe Character, assim:


char letra = 'a';
        
letra = Character.toUpperCase(letra); // Convertendo pra maiúsculaa
        
System.out.println(letra);
        
letra = Character.toLowerCase(letra); // Convertendo novamente pra minúscula
        
System.out.println(letra);

Agora vamos ver como faz para mostrar entrada de dados, o que não vem por padrão do Java.

Para isso, vamos importar a classe java.util.Scanner e criar um objeto com o comando Scanner. Veja um exemplo na prática:


import java.util.Scanner;

public class TiposPrimitivos {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in, "CP1252");
        System.out.print("Digite o nome do aluno:");
        String nome = teclado.nextLine();
        System.out.print("Digite a nota do aluno:");
        float nota = teclado.nextFloat();
        System.out.printf("A nota de %s é %.1f\n", nome, nota);
    } 
}

PS: Evite carregar todas as classes de um determinado pacote sem necessidade, isso ocorre usando algo como import java.util.*; (asterisco é um coringa pra "todos"), mas isso deixa o programa mais pesado.

Lembre-se dos métodos para ler importações, como descrito na tabelinha acima. Veja alguns exemplos:


int idade = teclado.nextInt();
float salario = teclado.nextFloat();
String nome = teclado.nextLine();
String login = teclado.next();
char letra = teclado.next().charAt(0);

O nextLine() pega uma linha inteira, e o next() apenas a primeira palavra. E pode ser necessário colocar como parâmetro do Scanner o charset para mostrar acentos, que pode ser ISO-8859-1, CP850 ou CP1252, como por exemplo Scanner(System.in, "CP1252").

PS: Caso o nextLine() não seja reconhecido, coloque outro nextLine() (não coloque next()) sem atribuir à nenhuma variável, antes do nextLine() da variável que deu erro. Isso é comum acontecer após usar números antes de strings. E se quiser remover espaços desnecessário de uma string, use o método trim() na variável.

Diferente de outras linguagens, o Java tem incompatibilidade entre tipos, principalmente de famílias diferentes, como nos valores numéricos e strings (que não são resolvidos com typecasts). Para resolver isso, convertemos os valores com classes invólucros.

Exemplo que converte int para String:


int idade = 30;
String valor = Integer.toString(idade);
System.out.println(valor);

Outro exemplo, que converte String para int:


String valor = "30";
int idade = Integer.parseInt(valor);
System.out.println(idade);

Terceiro exemplo, que converte String para float:


String valor = "30.5";
float idade = Float.parseFloat(valor);
System.out.println(idade);

Temos também outras opções, como a Float.toString() (que converte float para String), Boolean.parseBoolean() (que converte String para boolean), Boolean.toString() (que converte boolean para String) e outras opções parecidas para double e outros tipos.

Podemos converter uma string de uma moeda para float também, dessa forma:


String dinheiro = "R$ 125,94";

float grana = Float.parseFloat(dinheiro.replace(",", ".").replace("R$", "").trim());

System.out.println(grana);

PS: O método replace é utilizado basicamente para trocar alguma parte de alguma string por outra. Ele substitui todas as ocorrências de uma string.

Podemos também inverter uma string, dessa forma:


Scanner teclado = new Scanner(System.in, "CP1252");

System.out.print("Digite o Texto a ser Invertido: ");
String texto = teclado.nextLine();

StringBuilder frase = new StringBuilder(texto);
String invertida = frase.reverse().toString();

System.out.println(invertida);

Podemos usar o método trim() para remover espaços de strings, assim:


Scanner teclado = new Scanner(System.in, "CP1252");
System.out.print("Digite uma frase: ");
String texto = teclado.nextLine().trim();

System.out.println(texto);

O método substring seleciona determinados caracteres de uma string, contados a partir do zero até um número limite, o indexOf pode determinar esse limite:


String frase = "Estude Java! É Muito Legal!";

String selec = frase.substring(0, frase.indexOf("!"));

System.out.println(selec);

Para encontrar uma palavra em uma String, use o método contains, assim:


String frase = "Estude Java! É Muito Legal!";

if(frase.contains("Java")) {
    System.out.println("Palavra encontrada.");
}
else {
    System.out.println("Palavra não encontrada.");
}

Para ver se uma string está vazia, use o método isEmpty() do objeto, assim:


String nome = "";

System.out.println("Nome está vazio? " + nome.isEmpty());

PS: Isso não verifica valores null, para isso use nome == null.

Para ver a quantidade de caracteres de uma string, use o método length() do objeto, assim:


String frase = "Exemplo de String";

System.out.println("Quantidade de caracteres: " + frase.length());

Podemos concatenar strings usando o método concat, assim:


String frase = "Isso é uma String";
        
System.out.println(frase.concat(" com mais algo!"));

Para converter uma string em array de char, basta usar o método do objeto string toCharArray(), e pro contrário usamos o método String.valueOf, assim:


String frase = "Isso é uma String!";

char[] vetor = frase.toCharArray(); // Convertendo pra array de char

String novo = String.valueOf(vetor); // Convertendo array de char em string

Para dividir uma string ao encontrar um delimitador, podemos fazer assim:


String frase = "Exemplo de Frase";
String dividido[] = frase.split(" "); // Pode ser qualquer caractere.

System.out.println(dividido[0]);

Para criar constantes, basta declarar como uma variável, com static final no começo (que impedirá que ela seja modificada, o static indica que só terá uma cópia dessa variável na memória, o final impede a alteração do atributo) e sempre a coloque inicializada, elas geralmente são escritas em maiúsculas, assim:


static final double PI = 3.14159265359;

PS: As constantes são declaradas dentro da classe, mas fora do método principal e de qualquer outro método.

Agora vamos fazer um Java Swing, de forma que coloquemos dois números para somar, crie um frame e no botão, vá em Action Permorfed para isso, dessa vez usaremos o método getter, vamos ver um exemplo:


private void btnSomaActionPerformed(java.awt.event.ActionEvent evt) {                                        
    int n1 = Integer.parseInt(txtN1.getText());
    int n2 = Integer.parseInt(txtN2.getText());
    int s = n1 + n2;
    lblResultado.setText(Integer.toString(s));
}

PS: Lembre-se que get é pra pegar o texto, e set é pra mudar.

Vamos criar uma nova aplicação de Java Swing, para calcular idade (com imagens). Mas ao invés de caixa de texto, vamos usar caixas numéricas.

PS: Caixas numéricas podem ser configuradas, nas propriedades, como o model, que é pra definir o modelo de controle numérico, como data, números e listas, além de valores mínimos e máximos.

No modelo sugerido, colocaremos também uma propriedade que pegue o ano atual do sistema.

Para pegar o ano do sistema, fazemos assim, no construtor:


public NovoFrame() {
    initComponents();
    Calendar anoSys = Calendar.getInstance();
    int anoAt = anoSys.get(Calendar.YEAR);
    lblSys.setText(Integer.toString(anoAt));
}

E apenas isso você colocará no evento do botão:


int anoNs = (int)numAn.getValue();
Calendar anoSys = Calendar.getInstance();
int anoAt = anoSys.get(Calendar.YEAR);
int idade = anoAt - anoNs;
lblIdade.setText(Integer.toString(idade));

Não esqueça da importação java.util.Calendar. É só compilar.

PS: Caso queira que, além do botão, ele seja executado ao clicar enter, podemos usar o evento Key e KeyPressed nas caixas de texto, numéricas e outros, e escolher dentro do método a tecla que deverá ser pressionada, assim:


private void txtSenhaKeyPressed(java.awt.event.KeyEvent evt) {                                    
    if(evt.getKeyCode() == KeyEvent.VK_ENTER) { // Podemos utilizar outra tecla aqui, importe java.awt.event.KeyEvent
        // Coloque o mesmo código aqui.
    }
}

Operadores Aritmeticos e Classe Math

No Java, para realizar cálculos matemáticos, usamos a classe Math, que é uma classe para cálculos matemáticos.

Os operadores são os mesmos da maioria das linguagens, adição (+), subtração(-), multiplicação(*), divisão (/) e módulo(%).

Para exemplificar, vamos criar uma nova aplicação Java com classe principal. Veja um exemplo:


int n1 = 3;
int n2 = 5;
float m = (n1 + n2) / 2;
System.out.println("A média entre as notas é de " + m);

PS: O resultado deverá ser em float, se for int, o Java dará erro.

Vamos fazer com Java Swing agora, com duas caixas de textos, para dividir números. Após você desenhar as caixas de texto, faça um código desse tipo no evento do botão:


int n = Integer.parseInt(txtNum.getText());
int d = Integer.parseInt(txtDem.getText());
int div = n / d;
int res = n % d;
lblDiv.setText(Integer.toString(div));
lblRes.setText(Integer.toString(res));

Os operadores unários também são usados em Java (por ser herança do C), que são o pré e pós incremento e decremento.

Nesse caso, o pós-incremento funcionou melhor:


int numero = 5;
numero++;
System.out.println(numero);

Já nesse caso, funcionou melhor o pré-incremento:


int numero = 5;
int valor = 5 + ++numero;
System.out.println(valor);

PS: O mesmo vale para decremento.

Também usamos os operadores de atribuição, que nada mais são do que os operadores aritméticos seguidos do igual. Para fazer incrementos e decrementos com mais de 1, usamos os operadores de adição e subtração com atribuição. Veja um exemplo:


int x = 4;
x += 2;
System.out.println(x);

A operação acima pode ser feita com qualquer valor numérico e com qualquer operador aritmético.

No Java também podemos fazer exponenciações como raiz quadrada e coisas do tipo. Para usar isso em Java, usamos a classe Math, que possuí constantes e métodos internos para realizar cálculos matemáticos (por exemplo, o PI).

Valor	Significado	Exemplo de uso	Retorno
PI	Constante π	`Math.PI`	3.141592653589793
pow	Exponenciação	`Math.pow(5, 2)`	25
sqrt	Raiz Quadrada	`Math.sqrt(25)`	5
cbrt	Raiz Cúbica	`Math.cbrt(27)`	3
abs	Valor Absoluto	`Math.abs(-10)`	10
floor	Arredondamento para baixo	`Math.floor(3.9)`	3
ceil	Arredondamento para cima	`Math.ceil(4.2)`	5
round	Arredondamento aritmeticamente	`Math.round(5.6)`	6

Vamos utilizar alguns valores em Java Swing para calcular raiz quadrada, assim:


int n = Integer.parseInt(txtNum.getText());
float res = (float)Math.sqrt(n);
lblRes.setText(Float.toString(res));

Pode ver nesse caso que foi necessário typecast.

Vamos criar um exemplo de arredondamento em Java no terminal, assim:


float v = 8.9f;
int ar = (int)Math.round(v);
System.out.println(ar);

O Java também tem suporte à geradores de números, no caso dele, usamos o método Math.random(), que gerará um número entre 0 e 1. Veja um exemplo que ele gerará números decimais aleatórios:


double ale = Math.random();
System.out.println(ale);

Mas você também pode usar esse método com outros números, colocando os números que você vai trabalhar, multiplicando depois do random (por exemplo, 5 e 10, subtraindo em ordem decrescente), e depois de tudo, coloca o menor número pra somar. Veja o exemplo:

Exemplo simples:


double ale = Math.random() * (10 - 5) + 5; // Primeiro número gerará o intervalo e o segundo é o mínimo.
System.out.println(ale);

Ou, simplificando, também gerará números entre 5 e 10, que serão arredondados pra inteiros:


double ale = Math.random() * 5 + 5; // O primeiro 5 seria o mesmo que (10 - 5).
int n = (int)Math.round(ale);
System.out.println(n);

Convertendo pra inteiro:


double ale = Math.random();
int n = (int)Math.round(ale * (2000 - 20) + 20);
System.out.println(n);

Podemos também usar um objeto Random pra isso (pra isso importe java.util.Random):


Random aleatorio = new Random(); // Importe java.util.Random.
int num = aleatorio.nextInt(5); // Gerará números de 0 a 4.
     
System.out.println(num);

Para gerar números de 1 a 5:


int num = aleatorio.nextInt(5) + 1;

Para gerar números de 12 a 14:


int num = aleatorio.nextInt(3) + 12;

Ou seja, dentro do método nextInt, colocamos o intervalo (contando o mínimo), e a soma é o mínimo.

Se quiser verificar se um valor numérico retorna NaN (não numérico), podemos utilizar o método isNaN(), veja um exemplo simples de uso:


Scanner teclado = new Scanner(System.in, "CP1252");
int num;
double raiz;

System.out.print("Digite um número pra ver a raiz: ");
num = teclado.nextInt();

raiz = !Double.isNaN(Math.sqrt(num)) ? Math.sqrt(num) : 0.0; // Isso é um operador ternário, que verifica dados.

System.out.println("A raiz quadrada de " + num + " é " + raiz);

Podemos também converter números decimais para octal, hexadecimais e binários, e vice-versa:


Scanner teclado = new Scanner(System.in, "CP1252");

System.out.print("Digite o número em decimal: ");
int num = teclado.nextInt();

String binario = Integer.toBinaryString(num); // Converte Decimal para Binário
String hexa = Integer.toHexString(num).toUpperCase(); // Converte Decimal para Hexadecimal
String octal = Integer.toOctalString(num); // Converte Decimal para Octal

System.out.println(num + " convertido para binário: " + binario);
System.out.println(num + " convertido para octal: " + octal);
System.out.println(num + " convertido para hexadecimal: " + hexa);

// Convertendo novamente para decimal:

int decimal1 = Integer.parseInt(binario, 2); // Converte o Binário pra Decimal 
int decimal2 = Integer.parseInt(octal, 8); // Converte o Octal para Decimal
int decimal3 = Integer.parseInt(hexa, 16); // Converte o Hexadecimal para Decimal

System.out.println(binario + " convertido para decimal: " + decimal1);
System.out.println(octal + " convertido para decimal: " + decimal2);
System.out.println(hexa + " convertido para decimal: " + decimal3);

Vamos criar uma calculadora em Swing, que ao informar um valor, mostre o resto da divisão por 2, o cubo, a raiz quadrada, a raiz cúbica e o valor absoluto, tudo ao mesmo tempo. Com fotos e tudo. Veja o código:


int num = (int)inpNum.getValue();
int res = num % 2;
double cub = Math.pow(num, 3);
double rzQ = Math.sqrt(num);
double rzC = Math.cbrt(num);
int abs = Math.abs(num);

lblRes.setText(Integer.toString(res));
lblCub.setText(String.format("%.0f", cub));
lblRzQ.setText(String.format("%.2f", rzQ));
lblRzC.setText(String.format("%.2f", rzC));
lblAbs.setText(Integer.toString(abs));