Classes Numéricas

Estamos seguindo para, em breve, entrarmos nos tutoriais de programação usando SWING e AWT, resumidamente, janelas. Mas antes, veremos classes que se tornarão de extrema importância para o uso da manipulação dos dados. Essas classes são as que tem por base a classe abstrata Numbers e a classe String.

Em Java, além de podermos utilizar os tipos primitivos de dados, também podemos usufruir de classes completas para o tratamento desses tipos primitivos. Isso é uma grande vantagem quando métodos necessitam ou retornam objetos ao invés de tipos primitivos (o que é muito comum com os objetos do pacote SWING e AWT).

Outra vantagem dessas classes é que o próprio compilador é capaz de extrair os dados do objeto implicitamente e manipular seus dados como sendo simples dados primitivos, num processo descrito como box e unbox (encaixotar e desencaixotar).

Por exemplo, se quisermos somar dois inteiros que estão dentro de dois objetos inteiros, não precisaríamos fazer nada de especial, a não ser somá-los de fato, como se fossem dados primitivos. Veja:

public class SomarIntegers {
    public static void main(String[] args) {
        Integer var1 = 25;
        Integer var2 = 75;
        int resultado = var1 + var2; // somando dois objetos
        System.out.println(resultado);
    }
}

A princípio, a classe abstrata Number nos proporciona um conjunto de métodos que, logicamente, são possíveis acessar de qualquer classe numérica.

Obter Tipo Primitivo de um Objeto Numérico

Podemos utilizar os métodos *Value para obter um tipo primitivo de qualquer objeto numérico.

byteValue(): Obtém um valor primitivo byte.
shortValue(): Obtém um valor primitivo short (inteiro curto).
intValue(): Obtém um valor primitivo int (inteiro).
longValue(): Obtém um valor primitivo long (inteiro longo).
floatValue(): Obtém um valor primitivo float.
doubleValue(): Obtém um valor primitivo double.

Esses métodos são ótimos para passar de um tipo de dado para o outro sem nos preocuparmos com indução de tipo ou typecasting, pois a mudança é feita diretamente pelo objeto.

public class ConverterNumeros {
    public static void main(String[] args) {
        Byte meuByte = 5;
        Integer meuInt = 12345;
        Double meuDouble = 1234567.89;
        byte doubleParaByte = meuDouble.byteValue();
        int byteParaInteiro = meuByte.intValue();
        double inteiroParaDouble = meuInt.doubleValue();
        System.out.println("Byte: " + meuByte +
                " - para int: "	+ byteParaInteiro +
                "\nInteger: " + meuInt +
                " - para double: " + inteiroParaDouble +
                "\nDouble: " + meuDouble +
                " - para byte: " + doubleParaByte);
    }
}

Comparar Números

Para comparação de números, há dois métodos: compareTo() e equals().

O método compareTo() compara o objeto com um outro objeto da mesma classe ou número de tipo primitivo do mesmo tipo. Ele retorna 0 se o número comparado for igual, -1 se o número for menor ou 1 se o número for maior.

Equals() funciona de forma semelhante. Ele indica se o número comparado é igual ao argumento deste método, porém não diz se o argumento é maior ou menor que o valor do objeto. Outra diferença fica por conta de seu retorno que é um valor booleano (true ou false).

Classes Integer, Float, Short, Byte, Long e Double

Agora que temos a base de todas as classes numéricas, iremos para a descrição dos métodos contidos nessas classes, que apesar de diferentes, mantem uma similaridade muito grande.

Análise de Dados

A análise de dados consiste em tentar usar uma String que possa ser interpretada como tal objeto numérico usando o comando parse*. Caso a String não possa ser interpretada como um número, uma exceção (erro) é lançada.

Byte.parseByte(): analisa uma String para tenta atribuir um dado do tipo primitivo byte.
Short.parseShort(): analisa uma String para tenta atribuir um dado do tipo primitivo short.
Integer.parseInt(): analisa uma String para tenta atribuir um dado do tipo primitivo inteiro.
Long.parseLong(): analisa uma String para tenta atribuir um dado do tipo inteiro primitivo longo.
Float.parseFloat(): analisa uma String para tenta atribuir um dado do tipo primitivo float.
Double.parseDouble(): analisa uma String para tenta atribuir um dado do tipo primitivo double.

Se quisermos que, ao invés de um tipo primitivo de número, seja retornado um objeto, podemos trocar qualquer parse* por valueOf().

Em tipos inteiros, além de valueOf(), também podemos trocar parseInt, parseByte, parseShort e parseLong por decode().

Importante: As classes que se baseiam em números inteiros (Byte, Short, Long e Integer) possuem um segundo argumento do tipo inteiro opcional nos métodos parse* que indica a base do número inteiro, fazendo com que dessa forma possa ser interpretado números Decimais (base 10), Binários (base 2), Octais (base 8) e Hexadecimais (base 16).

Decode também pode fazer este tipo de interpretação, mas não é necessário um segundo argumento desde que a String respeite algumas convenções:

Não são aceitos espaços;
Não são aceitos números negativos;
Números octais devem começar com um 0 (ex.: "0377", "0400", "0401");
Números hexadecimais devem começar com 0x, 0X ou # (ex.: "0xFF", "0X100", "#101").

public class ParseEDecode {
    public static void main(String[] args) {
        String numero = "256";
        // retorna um dado do tipo int (inteiro)
        int tipoInteiro = Integer.parseInt(numero);
        // retorna um objeto da classe Integer (inteiro)
        Integer objetoInteiro = Integer.decode(numero);
        System.out.println("tipoInteiro: " + tipoInteiro +
                "\nobjetoInteiro: " + objetoInteiro);
    }
}