Difference between an Integer and int in Java with Examples
Last Updated :
29 Jul, 2024
Improve
In Java, int is a primitive data type while Integer is a Wrapper class.
- int, being a primitive data type has got less flexibility. We can only store the binary value of an integer in it.
- Since Integer is a wrapper class for int data type, it gives us more flexibility in storing, converting and manipulating an int data.
- Integer is a class and thus it can call various in-built methods defined in the class. Variables of type Integer store references to Integer objects, just as with any other reference (object) type.
Examples:
// Valid
int n = 20;
//valid
Integer n = 45;
// Valid
Integer.parseInt("10");
// Not Valid
int.parseInt("10");
Important Points of Difference:
1. Casting to String Variable
We can't assign a String value (containing an integer only) directly or even by casting to an int variable. However, we can assign a String to an object of Integer type using the Integer(String) constructor. We can even use parseInt(String) to convert a String literal to an int value.
// Java program to illustrate
// difference between
// int and Integer
public class Main {
public static void main(String args[])
{
Integer a = Integer.valueOf("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"));
}
}
20
1
// Java program to illustrate 2
// difference between 3
// int and Integer 4
5
public class Main { 6
public static void main(String args[]) 7
{ 8
9
Integer a = Integer.valueOf("123"); 10
// Casting not possible 11
// int a = (int)"123"; 12
// Casting not possible 13
// int c="123"; 14
15
// Casting possible using methods 16
// from Integer Wrapper class 17
int b = Integer.parseInt("123"); 18
System.out.print(a + new Float("10.1")); 19
} 20
}Output
133.1
2. Direct Conversion of value to other base
We can directly convert an integer value stored in Integer class to Binary, Octal or Hexadecimal format using toBinaryString(), toOctalString() or toHexString() respectively. This is not possible in a variable of int type.
// 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);
}
}
13
1
// Java program to illustrate 2
// difference between 3
// int and Integer 4
5
public class Main { 6
public static void main(String args[]) 7
{ 8
String bin = Integer.toBinaryString(123); 9
String oct = Integer.toOctalString(123); 10
String hex = Integer.toHexString(123); 11
System.out.print(bin + "\n" + oct + "\n" + hex); 12
} 13
}Output
1111011 173 7b
3. Performing operations on data
Integer class also allows us to reverse our number or rotate it left or right using reverse(), rotateLeft() and rotateRight() respectively. We need to define our own logic to perform these operations on an int variable as its not an inbuilt class.
// 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);
}
}
29
1
// Java program to illustrate 2
// difference between 3
// int and Integer 4
5
public class Main { 6
public static void main(String args[]) 7
{ 8
// mainethods convert integer to its binary form, 9
// apply the desired operation 10
// and then returns the decimal form 11
// of the newly formed binary number 12
// (12)10->(1100)2 -> 13
// rotate left by 2 units -> (110000)2->(48)10 14
int rL = Integer.rotateLeft(12, 2); 15
16
// (12)10->(1100)2 -> 17
// rotate right by 2 units -> (0011)2->(3)10 18
int rR = Integer.rotateRight(12, 2); 19
20
//(12)10 -> (00000000000000000000000000001100)2 21
// -> reverse ->(00110000000000000000000000000000)2 22
// -> (805306368)10 23
24
// int is of 32 bits 25
int rev = Integer.reverse(12); 26
System.out.print("Left Rotate : " + rL 27
+ "\nRight rotate : " + rR + "\nReverse : " + rev); 28
} 29
}Output
Left Rotate : 48 Right rotate : 3 Reverse : 805306368
4. Flexibility
Integer wrapper class provides us more flexibility to the existing int datatype. We are able to perform many operations on an int value besides the predefined operators. Integer class is used where we need to treat an int variable like an object. Since Wrapper classes inherit Object class, they can be used in collections with Object reference or generics. Thus we are adding the property of nullability to the existing int data type. Since Java 5, we have the concept of auto-boxing wherein a primitive data type is converted into a wrapper class and vice versa automatically. Hence, we can perform any arithmetic or logical operation between any primitive data type and any Wrapper class.
Note: The new Integer(String) constructor is deprecated in Java 9 and removed in Java 16. However, it is still supported in earlier versions (though it is not recommended to use it due to its deprecation)
- Java 9: The new Integer(String) constructor is deprecated.
- Java 16: The new Integer(String) constructor is removed.
// Java program to illustrate
// auto-boxing
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));
}
}
23
1
// Java program to illustrate2
// auto-boxing3
import java.util.function.Function;4
public class Main {5
public static void main(String args[])6
{7
8
Integer a = new Integer("12");9
Integer d = new Integer("13");10
int b = 2;11
double c = 3.1;12
Double f = new Double("12.1");13
int d2 = a + d;14
System.out.println("Sum of 2 Integer objects :"15
+ (a + d));16
System.out.println("Sum of an Integer object 17
and int value :" + (a + b)); 18
System.out.println("Sum of an Integer object 19
and double value :" + (a + c)); 20
System.out.println("Sum of an Integer object 21
and Double object :" + (a + f)); 22
}23
}Running this Code
- Java 8: The code will compile and run, but using
new Integer(String)will generate a warning. - Java 9 to Java 15: The code will compile and run, but using
new Integer(String)will generate a deprecation warning. - Java 16 and Later: Using
new Integer(String)will cause a compilation error. You must useInteger.valueOf(String).
It's best to avoid using deprecated constructors and follow the current best practices to ensure compatibility with future Java versions.
In Java 16 and later versions, using new Integer("12") will result in a compilation error. The recommended approach is to use Integer.valueOf("12")
/*package whatever //do not write package name here */
// Java program to illustrate
// auto-boxing
import java.util.function.Function;
public class Main {
public static void main(String[] args) {
// Use valueOf instead of new Integer to avoid deprecated constructor usage
Integer a = Integer.valueOf("12");
Integer d = Integer.valueOf("13");
int b = 2;
double c = 3.1;
// Use valueOf instead of new Double to avoid deprecated constructor usage
Double f = Double.valueOf("12.1");
// Correct variable name
int d2 = a + d;
// Corrected print statements
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));
}
}
25
1
/*package whatever //do not write package name here */2
// Java program to illustrate3
// auto-boxing4
import java.util.function.Function;5
6
public class Main {7
public static void main(String[] args) {8
// Use valueOf instead of new Integer to avoid deprecated constructor usage9
Integer a = Integer.valueOf("12");10
Integer d = Integer.valueOf("13");11
int b = 2;12
double c = 3.1;13
// Use valueOf instead of new Double to avoid deprecated constructor usage14
Double f = Double.valueOf("12.1");15
16
// Correct variable name17
int d2 = a + d;18
19
// Corrected print statements20
System.out.println("Sum of 2 Integer objects: " + (a + d));21
System.out.println("Sum of an Integer object and int value: " + (a + b));22
System.out.println("Sum of an Integer object and double value: " + (a + c));23
System.out.println("Sum of an Integer object and Double object: " + (a + f));24
}25
}Output
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
Besides Integer, we have more wrapper classes in Java corresponding to the data types. These are given as follows :
Equivalent Wrapper Classes of Primitive Types in Java
| Primitive Data Type | Wrapper Class |
|---|---|
boolean | Boolean |
char | Character |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
