int vs Integer Java

In Java, we use int and Integer to store integer types of data. Now, the question that comes from here is that if both are used to store the same type of data, then what is the difference between both of them, and why we need both of them? So, the main difference between the int and Integer is that the int is of primitive data type while the Integer is of class type. In the development of the OOPs application, int behaves according to the principle of the primitive data type. On the other hand, Integer doesn't follow the principle of primitive data type and behaves like a wrapper class.

Let's dive into detail and understand some other important differences between int and Integer.

Difference between int and Integer

Sr. No.	Factor	int	Integer
1.	Type	An int is a primitive data type that is capable of storing 32-bit signed two's complement integer.	An Integer is a wrapper class for the int data type that gives us more flexibility in converting, storing, and manipulating int data.
2.	Flexibility	An int only allows the binary value of an integer in it, and due to which it is provides less flexibility.	An Integer is a wrapper class for int and provides more flexibility in comparison to the int.
3.	Purpose	It is used for only a single purpose, i.e., storing an integer value into memory.	Its main purpose is to convert an int into an object or an object into an int.
4.	Memory use	It takes 4 bytes to store an integer value in it.	It takes 16 bytes to store an integer value in it.
5.	Base conversion	We cannot convert the integer value of int into another base.	The Integer class provides several useful methods, such as toBinaryString(), toOctalString(), and toHexString(), that allows us to directly convert the integer value stored in the Integer.
6.	Type Casting	We cannot pass the decimal and string value to an int type variable. Casting is also not supported for that.	Integer provides several ways to pass a decimal or string value to an object of Integer type. The Integer(String) and the parseInt(String) are the two ways through which we can convert a string to an int value.
7.	Operations	Operations are not allowed because of not using the inbuilt functions.	We can perform operations such as reversing a number, rotating it left, or rotating it right.

Let's take some examples related to Casting, Base conversion, Operations, and Flexibility to understand the differences between both of them.

CastingExample.java

//creating CastingExample class to understand difference between int and Integer based on casting  
public class CastingExample { 
	//main() method starts
	public static void main(String args[]) 
	{ 
		//creating an integer by taking a string value
		Integer data = new Integer("987"); 

		// int data = (int)"987";		we cannot typecast string to int 
		// int newData = "987";		we cannot directly pass string value to int 

		// by using the parseInt() method of the Integer Wrapper class, we can perform casting
		int newData = Integer.parseInt("987"); 
		
		//print newData, i.e., of type int
	System.out.print(data+" "+newData); 
	} 
}

Output:

CastingExample.java

//create BaseConversionExample class to convert the integer value into different bases
public class BaseConversionExample { 
	//main() method starts
    public static void main(String args[]) 
    {	
		//change the base to binary
        String binVal = Integer.toBinaryString(987);
		
		//change the base to octal
        String octVal = Integer.toOctalString(98); 
        
		//change the base to hexadecimal
		String hexVal = Integer.toHexString(987);
			
        System.out.print("Binary value of 987 is: " + binVal + "\nOctal value of 987 is: " + octVal + "\nHexadecimal value of 987 is: " + hexVal); 
    } 
}

Output:

FlexibilityExample.java

//import classes and packages that are required
import java.util.function.Function; 
import java.util.function.Function; 

//create FlexibilityExample class to check flexibility of the wrapper class
public class FlexibilityExample { 
	//main() method starts
    public static void main(String args[]) 
    { 
		
        Integer x = new Integer("23");		//create an integer variable x of type object  
        Integer y = new Integer("55"); 		//create an integer variable y of type object
        
		int p = 12;		//create an integer variable p of primitive type 
        
		double q = 4.23;	//create a varibale q of type double 
		
        Double z = new Double("8.6");		//create a variable x of type object that holds double value  
        
		//print the sum of 2 Integer objects  
        System.out.println("Sum :" + (x + y)); 
        
		//print the sum of a double object and an Integer object
		System.out.println("Sum :" + (y + z)); 
    
		//print the sum of an int value and an Integer object
		System.out.println("Sum :" + (p + x)); 
        
		//print the sum of a double value and an Integer object
		System.out.println("Sum :" + (q + y)); 
 
	} 
}

Output: