Integer Wrapper class in Java

We have wrapper classes in Java that provide a mechanism to wrap primitive values in an object so that primitives can be used for the operations reserved only for objects. One such wrapper class is the Integer wrapper class which wraps an int primitive to facilitate object operations.

The Integer class is present in java.lang package.

Declaration of the Integer class

public final class Integer extends Number
        implements Comparable<Integer>, Constable, ConstantDesc

Here, Number is the abstract class that has declared xxxValue() methods like intValue(), floatValue(), etc. which is then implemented by the Integer class.

How to make an object of the Integer class?

We can make the objects of the Integer class in several ways

• Using Integer(int value) constructor
• Using public Integer(String s) constructor
• By the use of valueOf() method

Let’s look at all of the above methods, and we will also see which of the above methods should be preferred to make objects of the Integer Wrapper class.

– Using Integer(int value) constructor

• Constructor declaration – public Integer(int value)
• What does it do? It will construct an object of the Integer wrapper class representing the value of the int primitive type passed in the arguments. This constructor has been deprecated since java 9 and is thus not recommended to use it.

Code Example

public class Codekru {

	public static void main(String[] args) {

		Integer i = new Integer(5); // creating an Integer instance
		System.out.println("Integer object value: " + i);
	}
}

Output –

Integer object value: 5

– Using Integer(String s) constructor

• Constructor declaration – public Integer(String s) throws NumberFormatException
• What does it do? It will construct an object of the Integer class representing the value of the string parameter passed in the arguments. This constructor is also deprecated since java 9 and is not recommended to use anymore.

The string passed must contain only the decimal characters and an optional positive or negative sign at the start. If we pass any other characters, then it will throw a NumberFormatException.

// Below are the correct ways of passing a string into the constructor's argument
 
 Integer i1 = new Integer("5"); 
 Integer i2 = new Integer("+5");
 Integer i3 = new Integer("-5");

// And below are the wrong ways

Integer i4 = new Integer("five");
Integer i5 = new Integer("5five");

Code Example

public class Codekru {

	public static void main(String[] args) {

		Integer i1 = new Integer("5");
		Integer i2 = new Integer("+5");
		Integer i3 = new Integer("-5");

		System.out.println("Integer object value for i1: " + i1);
		System.out.println("Integer object value for i2: " + i2);
		System.out.println("Integer object value for i3: " + i3);
	}
}

Output –

Integer object value for i1: 5
Integer object value for i2: 5
Integer object value for i3: -5

Internal implementation of the Integer(String s) constructor

Integer(String s) constructor internally uses the parseInt(s, 10) method.

    public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

– Using valueOf() method

valueOf() method has three overloaded methods discussed in this post. The valueOf() method is the preferred way to make the Integer instance as it yields significantly better space and time performance by caching frequently requested values.

Code Example

public class Codekru {

	public static void main(String[] args) {

		Integer i1 = Integer.valueOf(12);
		Integer i2 = Integer.valueOf("15");

		System.out.println("Integer object value for i1: " + i1);
		System.out.println("Integer object value for i2: " + i2);
	}
}

Output –

Integer object value for i1: 12
Integer object value for i2: 15

Comparing and caching in Integer Class Objects

How we can compare and check the equality between two Integer class objects?

We can compare two integer objects using the equals() method or the comparison operator ( == ).

equals() method compares the primitive values stored by a wrapper instance, whereas == compares the object references only. Let’s show you this with an example.

public class Codekru {

	public static void main(String[] args) {
		Integer i1 = Integer.valueOf(1234);
		Integer i2 = Integer.valueOf(1234);

		if (i1.equals(i2)) {
			System.out.println("Both are equal");
		} else {
			System.out.println("Both aren't equal");
		}

	}
}

Both are equal

public class Codekru {

	public static void main(String[] args) {
		Integer i1 = Integer.valueOf(1234);
		Integer i2 = Integer.valueOf(1234);

		if (i1 == i2) {
			System.out.println("Both are equal");
		} else {
			System.out.println("Both aren't equal");
		}

	}
}

Both aren't equal

• == operator only compares the references and not the values contained within the object, and that’s why i1==i2 returned false because they were two different instances. However, the value within them was the same.
• On the other hand, the equals() method compares the value and not the references. Because of this, i1.equals(i2) returned true as both the integers have the same value despite being two different instances.

Caching in the Integer wrapper classes

Integer wrapper classes cache the wrapper objects for values between -128 to 127. So, if we again make an integer object of the values between -128 and 127, no new object will be created, and the object will be picked from the cache made by the integer class.

Let’s show you an example –

public class Codekru {

	public static void main(String[] args) {
		Integer i1 = Integer.valueOf(30);
		Integer i2 = Integer.valueOf(30);

		if (i1 == i2) {
			System.out.println("Both are equal");
		} else {
			System.out.println("Both aren't equal");
		}

	}
}

Both are equal

public class Codekru {

	public static void main(String[] args) {
		Integer i1 = Integer.valueOf(130);
		Integer i2 = Integer.valueOf(130);

		if (i1 == i2) {
			System.out.println("Both are equal");
		} else {
			System.out.println("Both aren't equal");
		}

	}
}

Both aren't equal

• In the case of our 1^st example, i2 was picked from the cache, and thus i1==i2 resulted in true value.
• Whereas in the 2^nd example, a new object was made for i2, and so, i1==i2 resulted in a false value.

Methods of the Integer wrapper class

We hope that you have liked the article. If you have any doubts or concerns, please feel free to write us in the comments or mail us at admin@codekru.com.

Related Articles

• Wrapper Classes in Java
• Boolean Wrapper Class in Java
• Long Wrapper Class in Java