xxxValue()
Quando é necessário converter o valor de um objeto wrapper para um primitivo, utiliza-se um dos métodos xxxValue(), onde xxx é o nome do primitivo para o qual será feita a conversão. Todos os métodos dessa família não possuem argumentos.
Cada uma das seis classes wrapper numéricas possuem seis métodos, de modo que qualquer objeto numérico wrapper pode ser convertido para qualquer tipo numérico primitivo. As classes wrapper não numéricas possuem apenas um método xxxValue().
public class TestxxxValue {
public static void main(String[] args) {
Integer i2 = new Integer(42);
//converte o Integer para o primitivo byte
byte b = i2.byteValue();
//convert o Integer para o primitivo short
short s = i2.shortValue();
//converte o Integer p/ o primitivo double
double d = i2.doubleValue();
Float f2 = new Float(3.14f );
//converte o Float para o primitivo short
short s2 = f2.shortValue();
/* imprime 3 porque no momento da
* conversão a literal perde as casas
* decimais, já que o short é inteiro */
System.out.println(s2);
}
}
parseXxx() e valueOf()
Os seis métodos parseXxx() , um para cada classe wrapper numérica, são parecidos com o valueOf(), que existe em todas as classes wrapper numéricas.
Os dois possuem uma String como argumento, lançam a exceção NumberFormatException se o argumento não tiver o formato apropriado, e podem converter objetos String de diferentes bases, quando o tipo primitivo em questão for qualquer um dos quatro tipos inteiros. A diferença entre os dois métodos é que o parseXxx() retorna um primitivo e o valueOf() retorna um novo objeto wrapped do tipo invocado pelo método.
public class TestparseXxx_valueOf {
public static void main(String[] args) {
//parseXxx converte de String p/ primitivo
double d4 = Double.parseDouble("3.14");
//valueOf converte se String p/ objeto
Double d5 = Double.valueOf("3.14");
//converte uma String (base2) p/ primitivo
long L2 = Long.parseLong("101010", 2);
//converte uma String (base2) p/ objeto
Long L3 = Long.valueOf("101010", 2);
}
}
toString()
A classe Object possui o método toString(). Como todas as classes herdam de Object, então todas as classes possuem esse método. A idéia desse método é permitir que se obtenha uma representação significativa de um dado objeto.
Consequentemente, todas as classes wrapper possuem uma instância sem argumento e não-estática desse método. Esse método retorna uma String com o valor primitivo do objeto.
Além disso, todas as classes wrapper fornecem um método toString() sobrecarregado e estático que recebe um tipo primitivo numérico apropriado e retorna uma String.
Interger e Long fornecem um terceiro método toString(), que é estático, seu primeiro argumento é um primitivo, o segundo argumento é a base e retorna uma String; por default o primeiro argumento está na base 10.
public class Test_toString {
public static void main(String[] args) {
Double db = new Double("2.55");
// imprime 2.55
System.out.println(db.toString());
String valor = Double.toString(2.55);
//imprime 2.55
System.out.println(valor);
//base 16
String valor2 = Long.toString(156, 16);
//imprime 9c
System.out.println(valor2);
}
}
toXxxString() - Binário, Hexadecimal e Octal
O Integer e Long permite converter números da base 10 para outras bases. Esses métodos de conversão recebem um int ou long, e retornam uma String do número convertido.
public class Test_toXxxString {
public static void main(String[] args) {
//converte 166 para a base 16
String s = Integer.toHexString(166);
//imprime a6
System.out.println(s);
//converte 166 para a base 8
String s2 = Long.toOctalString(166);
//imprime 246
System.out.print(s2);
}
}
Fonte: SCJP Sun Certified Programmer for Java 6 Study Guide
