Diferencia entre un entero y un int en Java con ejemplos

En Java, int es un tipo de datos primitivo mientras que Integer es una clase Wrapper .

• int, al ser un tipo de datos primitivo tiene menos flexibilidad. Solo podemos almacenar el valor binario de un número entero en él.
• Dado que Integer es una clase contenedora para el tipo de datos int, nos brinda más flexibilidad para almacenar, convertir y manipular datos int.
• Integer es una clase y, por lo tanto, puede llamar a varios métodos integrados definidos en la clase. Las variables de tipo Integer almacenan referencias a objetos Integer, al igual que con cualquier otro tipo de referencia (objeto).

Ejemplos:

// Valid
int n = 20;
//valid
Integer n = 45;

// Valid
Integer.parseInt("10");
// Not Valid
int.parseInt("10");

Puntos importantes de diferencias:

1. Conversión a variable de string: no podemos asignar un valor de string (que solo contenga un número entero) a una variable int directamente o incluso mediante conversión. Sin embargo, podemos asignar un String a un objeto de tipo Integer utilizando el constructor Integer(String). Incluso podemos usar parseInt(String) para convertir un literal de string en un valor int.

   // Java program to illustrate  // difference between // int and Integer     public class Main {     public static void main(String args[])     {            Integer a = new Integer("123");         // Casting not possible         // int a = (int)"123";         // Casting not possible         // int c="123";            // Casting possible using methods         // from Integer Wrapper class         int b = Integer.parseInt("123");         System.out.print(a + new Float("10.1"));     } }

   Producción:

   133.1
   

2. Conversión directa de valor a otra base: podemos convertir directamente un valor entero almacenado en la clase Integer a formato binario, octal o hexadecimal usando toBinaryString(), toOctalString() o toHexString() respectivamente. Esto no es posible en una variable de tipo int.

   // Java program to illustrate  // difference between // int and Integer     public class Main {     public static void main(String args[])     {         String bin = Integer.toBinaryString(123);         String oct = Integer.toOctalString(123);         String hex = Integer.toHexString(123);         System.out.print(bin + "\n" + oct + "\n" + hex);     } }

   Producción:

   1111011
   173
   7b
   

3. Realización de operaciones sobre datos: la clase Integer también nos permite invertir nuestro número o rotarlo hacia la izquierda o hacia la derecha usando reverse(), rotar a la izquierda() y rotar a la derecha() respectivamente. Necesitamos definir nuestra propia lógica para realizar estas operaciones en una variable int ya que no es una clase incorporada.

   // Java program to illustrate  // difference between // int and Integer     public class Main {     public static void main(String args[])     {         // mainethods convert integer to its binary form,         // apply the desired operation          // and then returns the decimal form         // of the newly formed binary number         // (12)10->(1100)2 ->          // rotate left by 2 units -> (110000)2->(48)10         int rL = Integer.rotateLeft(12, 2);            // (12)10->(1100)2 ->          // rotate right by 2 units -> (0011)2->(3)10         int rR = Integer.rotateRight(12, 2);            //(12)10 -> (00000000000000000000000000001100)2          // -> reverse ->(00110000000000000000000000000000)2         // -> (805306368)10                    // int is of 32 bits         int rev = Integer.reverse(12);         System.out.print("Left Rotate : " + rL            + "\nRight rotate : " + rR + "\nReverse : " + rev);     } }

   Producción:

   Left Rotate : 48
   Right rotate : 3
   Reverse : 805306368
   

4. Flexibilidad: la clase contenedora de enteros nos brinda más flexibilidad para el tipo de datos int existente. Podemos realizar muchas operaciones en un valor int además de los operadores predefinidos. La clase Integer se usa cuando necesitamos tratar una variable int como un objeto. Dado que las clases Wrapper heredan la clase Object, se pueden usar en colecciones con referencia a Object o genéricas. Por lo tanto, estamos agregando la propiedad de nulabilidad al tipo de datos int existente.
   Desde Java 5, tenemos el concepto de auto-boxing en el que un tipo de datos primitivo se convierte en una clase contenedora y viceversa automáticamente. Por lo tanto, podemos realizar cualquier operación aritmética o lógica entre cualquier tipo de dato primitivo y cualquier clase Wrapper.

   // Java program to illustrate // auto-boxing import java.util.function.Function; import java.util.function.Function; public class Main {     public static void main(String args[])     {            Integer a = new Integer("12");         Integer d = new Integer("13");         int b = 2;         double c = 3.1;         Double f = new Double("12.1");         int d2 = a + d;         System.out.println("Sum of 2 Integer objects :"              + (a + d));         System.out.println("Sum of an Integer object              and int value :" + (a + b));         System.out.println("Sum of an Integer object              and double value :" + (a + c));         System.out.println("Sum of an Integer object              and Double object :" + (a + f));     } }

   Producción:

   Sum of 2 Integer objects :25
   Sum of an Integer object and int value :14
   Sum of an Integer object and double value :15.1
   Sum of an Integer object and Double object :24.1
   

Además de Integer, tenemos más clases contenedoras en Java correspondientes a los tipos de datos. Estos se dan de la siguiente manera:

Clases contenedoras equivalentes de tipos primitivos en Java