Wrappers em Java: Aprenda como utilizar

Se voc� j� trabalhou com Java, mesmo que por pouco tempo j� deve ter trabalhado alguma vez com Wrappers e nem percebeu. Este artigo tem como principal objetivo mostrar a import�ncia dos Wrappers e principalmente o que eles s�o.

Wrappers vem do verbo ingl�s �wrap� que significa envolver. Eles s�o um nome adicional ao padr�o de projeto Decorator. Tem como principal funç�o �envolver coisas� adicionando funcionalidades � ela.

O Java conta com diversos Wrappers que adicionam funcionalidades a outras classes ou tipos primitivos, um exemplo dele � o Integer, que � o Wrapper do tipo primitivo int. Que tipo de funcionalidade voc� pode executar tendo apenas uma vari�vel definida como �int�? Nenhuma, a n�o ser atribuir valores, pois int � um tipo primitivo e n�o possu� m�todos.

O Java possui oito wrappers para tipos primitivos que adicionam a funcionalidade de tratar tipos primitivos como classes. Quando voc� faz um:
Integer i = Integer.valueOf(2); Voc� est� criando uma classe, que "envolve" o n�mero 2 (primitivo) e adiciona m�todos como intValue() nele. Voc� ainda ganha a funcionalidade de trabalhar com o n�mero 2 como se ele fosse um objeto. O Java (a partir da vers�o 5) � inteligente o suficiente para criar ou desfazer wrappers de tipo primitivo automaticamente (Autoboxing), de t�o �til e comum que � essa pr�tica, veremos mais a diante como funciona o Autoboxing.

Existem dezenas de wrappers: para tratar o fluxo de conex�es como orientado a objetos (ObjectInputStream), fluxos de audio (AudioInputStream), baseados em tipos primitivos (DataInputStream), ou adicionar buffers (BufferedInputStream) a eles. Todos esses s�o exemplos de wrappers para o b�sico e sem funcionalidade InputStream. E o interessante, � que, esses wrappers podem ser combinados (pode-se fazer um FileInputStream, associa-lo a um BufferedInputStream e ler dados primitivos dele ap�s associar o resultado a um DataInputStream).

Com o Wrapper Integer envolvendo o tipo primitivo int voc� consegue executar m�todos como � o caso do: parseInt, valueOf e assim por diante.

Na Figura 1voc� confere uma lista de Wrappers muito comuns no Java.

Figura 1. Wrappers de Tipos primitivos

Ent�o se temos Wrappers porque usar os tipos primitivos? Simples, eles s�o mais r�pidos e consomem menos mem�ria, afinal n�o tem implementaç�o de m�todos ou qualquer outro algoritmo complexo que venha a consumir mais tempo da JVM.

Fique atento ao tentar realizar convers�es de para Wrappers do tipo errado, pois voc� ver� exceç�es como �NumberFormatException�, como por exemplo a tentativa de converter o literal �dois� para um tipo �Integer�. A atenç�o deve ser dobrada pois n�o h� erro em tempo de compilaç�o, ou seja, seu c�digo n�o mostrar� nenhum erro de sintaxe, mas quando esta linha de c�digo for executada voc� ver� a exceç�o apontada acima. Veja o exemplo da Listagem 1.

Listagem 1. Convertendo de forma errada


  public class ExceWrap {
    public static void main(String[] args) {
      int z= Integer.parseInt("dois");
      System.out.println(z);
      /* codigo compila sem problemas mais uma excecao vai acontecer
       * nao h� nada de errado na sintaxe
       * porem a jvm nao consegue converter uma string literal
       * em um numero inteiro
       */
   }}
   Exception in thread "main" java.lang.NumberFormatException: For input string: "dois"
   
  //Por outro lado, a classe abaixo ir� compilar e executar normalmente
  public class Par {
    public static void main(String[] args) {
       //String - primitivo
       double d = Double.parseDouble("10");
       System.out.println(d);
  }}
   
  //A classe abaixo tamb�m apresentar� erro
   
  public class NoValue {
   public static void main(String[] args) {
      Long l = new Long(8);
      int lh = l.longValue();
      /* nao compila o to tentando colocar um long
       * dentro de um int nao � valido isso
       */
   }}
   
  //Esta funcionar� normalmente
  public class OfVal {
   public static void main(String[] args) {
      //String --> OBJETOS
      Float f = Float.valueOf("10");
      System.out.println(f);
      Integer i = new Integer(10);
      //Objeto --> Primitivo
      int g = i.intValue();
    }}
   
    //Veja um exemplo de teste de refer�ncia
    public class WrpObjt {
      public static void main(String[] args) {
        Integer g = new Integer (10);
        Integer h = new Integer(10);
        System.out.println(g==h);//false
         /* aqui dois objetos diferentes
          * porem com mesmo valor
          * == testa a referencia e nao valores dos 
          * objetos */}}

Atente tamb�m que tipos primitivos n�o podem ser utilizados em Collections, s� objetos. Sendo assim, a soluç�o � usar Wrappers. E j� que estamos no assunto de Wrappers, n�o poder�amos falar da novidade trazida pelo Java 5, o Autoboxing que ser� explicado na pr�xima seç�o.

Autoboxing com Wrappers

Voc� j� deve ter se imagine que como Wrapper � um Objeto voc� deve sempre passar um tipo primitivo para criar um Wrapper especifico daquele tipo primitivo, algo como mostrado na Listagem 2.

Listagem 2. Criando um Wrapper


  Integer soma = new Integer(10);

�timo, e se quisermos criar um Hashmap ter�amos que fazer algo como mostrado na Listagem 3.

Listagem 3. Criando uma lista sem Autoboxing


  HashMap hashMap = new HashMap();
  hashMap.put(new Integer(10), �Carlos�);
  hashMap.put(new Integer(11), �Jose�);
  hashMap.put(new Integer(12), �Pedro�);

Ap�s o Java 5 surgiu a funcionalidade do Autoboxing onde o pr�prio Java j� converte o tipo primitivo em Wrapper se este achar que � necess�rio. Veja a Listagem 4 com Autoboxing funcionando.

Listagem 4. Criando uma lista com Autoboxing


  HashMap hashMap = new HashMap();
  hashMap.put(10, �Carlos�);
  hashMap.put(11, �Jose�);
  hashMap.put(12, �Pedro�);

Boxing Conversion

O Boxing � a convers�o de tipos primitivos em seu respectivo Wrapper correspondente, ou seja, veja o exemplo na Listagem 5.

Listagem 5. Boxing Conversion


  Boolean meuBoolean = true; 
  //a convers�o � feita de forma autom�tica para o boolean
  Integer meuInteger = 1203; 
  Double meuDouble = 10.20;

� �bvio que se voc� tentar realizar um Boxing Conversion de um tipo primitivo para um Wrapper errado voc� ter� um erro de compilaç�o.

Unboxing Conversion

O Unboxing Conversion � quando voc� deseja fazer o inverso feito na seç�o 2.1, ou seja, deseja converter um objeto para um tipo primitivo. Veja os exemplos na Listagem 6.

Listagem 6. Exemplos de Unboxing Conversion


  boolean a = new Boolean(�True�);
  char c = new Character(�c�);
  byte b = new Byte(�1�);
  float f = new Float(1.0f);

Comparando Wrappers

Possivelmente voc� j� deve ter comparado Strings em Java, e deve saber que utilizar o operador �==� n�o funciona, � por isso que a implementaç�o no m�todo equals nos �Pojos� s�o muito importantes. Com os Wrappers voc� tamb�m deve utilizar o m�todo equals para realizar estes tipos de comparaç�es, n�o esqueça que Wrappers s�o objetos e n�o tipos primitivos.

Veja na Listagem 7 uma comparaç�o certa e outra errada.

Listagem 7. Comparando Wrappers da forma certa e da forma errada


  Integer a = 200;
  Integer b = 200;
  a.equals(b); // Retorna TRUE
  a == b; // Retorna FALSE

A diferença entre o equals e o operador ==, � que no operador == ele compara a refer�ncia do objeto, afinal voc� est� literalmente �comparando� os objetos e mesmo que estes fossem id�nticos (em todos os atributos) eles ocupam locais diferentes na mem�ria e possuem identificaç�o diferente na JVM, resumindo n�o s�o iguais. Utilizando o equals voc� compara o valor deles, igual como se tivesse comparando dois tipos primitivos.

O Problema encontrado

Quando falamos que voc� n�o deve utilizar o == para comparar Wrappers, � porque n�o deve mesmo e continuamos afirmando isso. Ainda afirmamos que quando voc� realizar esse tipo de comparaç�o receber� FALSE, visto que ele compara a refer�ncia em mem�ria do objeto. O problema � que se voc� fizer o teste da Listagem 8 ver� que ele retornar� verdadeiro.

Listagem 8. Comparando Wrappers com o operador ==


  Integer x = 120;
  Integer y = 120;
  x==y; //Retorna TRUE

Porque ent�o o exemplo da Listagem 8 retorna TRUE? Por causa do padr�o de projeto Flyweigth. Ele tenta reduzir o consumo de mem�ria mudando a refer�ncia dos objetos que s�o id�nticos, ou seja, os objetos x e y apontam para um mesmo objeto com que tem as caracter�sticas ditando que o valor � 120, assim quando compararmos com ==, j� que estamos comparando a refer�ncia do objeto e ela � a mesma com o Flyweigth o resultado ser� TRUE. Isso por padr�o s� � aplicado nos valores de -128 at� 127, mas na d�vida use sempre o equals.

Possivelmente, como citamos no inicio do artigo, voc� j� deve ter usado Wrapper em algum momento, mas nunca soube de fato o que era, na verdade isso acaba sendo t�o autom�tico que muitas das vezes voc� deve ter usado o Integer, Float ou Boolean Wrapper pensado que � um tipo primitivo, quando na verdade voc� est� envolvido pela Orientaç�o � Objetos.

A import�ncia deste nem precisa ser descrita, j� que s�o utilizados com freq��ncia e fazem a maior parte do trabalho quando precisamos. Al�m disso, existem mais Wrappers do que apenas de tipos primitivos, faça uma pesquisa sobre estes e encontrar� um mundo de novos conceitos e aprendizados.

Wrappers n�o s�o utilizados apenas com tipos primitivos, pelo seu conceito de �envolver coisas�, podemos utiliz�-los em objetos, por exemplo: Imagine que voc� quer adicionar mais funcionalidades a um Jbutton padr�o, ent�o voc� poderia criar um Wrapper chamado WrapperJButton que conteria o Jbutton e mais v�rios m�todo que voc� acha necess�rio para sua aplicaç�o.