Java int, Integer and long/Long Data Types

int x = 5;

Integer y = new Integer(5);

long x = 4000000000L;

Long y = new Long(4000000000L);

There are certain scenarios when you need to work with objects rather than using primitive data types for storing numeric values.

I will explain this in the later part of this tutorial. First, have a look at a few examples of declaring and using the int and long data types.

An example of using Java int type

This is how you may declare and use the int type variables in Java programs. See this example where I have declared and assigned values to int types variables in two ways:

Java code for int example:

public class java_variables {

    public static void main(String []args) {

      //Declaring int type variables

        int num_a,sum_c;
        int num_b= 500000;

        num_a= 150000;

        //Getting sum of two numbers

        sum_c = num_a + num_b;
     System.out.println("The sum of two int variables is = " + sum_c);
  }

}

The result:

You can see that the first line is used only to declare two int type variables.

The value is assigned to the num_a after declaring it. In the second line, the num_b is declared and a value is assigned at the time of declaration.

The example of using int variable in for loop

See this example where an int type variable is used in a for loop. The variable is declared inside the loop and used with a Java array for displaying the array elements.

The code:

public class java_variables {

                   public static void main(String []args) {
                        int[] Intarr = {5,10,15,20,25,30,35};

                        //Declaring int type variable inside the for loop

                        for (int ArrItem : Intarr) {

                            System.out.println("The numeric array value: " + ArrItem);

                        } 
                    }

}

The Output:

Using the long Java data type example

Just like the int type variables, the long type is declared. You may assign a value at the time of declaration or after that.

As mentioned earlier, the long type takes 64 bits of memory, so may store a much larger value than the int type, which takes 32 bits.

Have a look at the following example where long type variables are declared and assigned the values and used in the calculation. For demonstration, the values of long variables are kept a little higher than the limit of the int type:

Java code:

public class java_variables {

    public static void main(String []args) {

                //Declaring long type variables

        long num_a,sum_c;
        long num_b= 2147483649L;

        num_a= 2147483649L;

        //Getting sum of two long numbers
       sum_c = num_a + num_b;

     System.out.println("The sum of two long variables is = " + sum_c);

  }

}

Output of the above code:

The values for the long type variable are used with “L” at the end.

A few main points about the int and long types

Before going into examples of using the Java Integer and Long classes, let us have a look at a few important points of int and long data types and Integer/Long classes.

The int and integer

The long (primitive type) and Long class:

An example of using the integer class

In this simple example of using the Integer class, three variables are declared just like the above examples. Two are assigned the values and the third Integer variable is the sum of the other two. Have a look:

Code with Integer class:

public class java_variables {

    public static void main(String []args) {

        //Declaring Integer type variables

        Integer num_a,sum_c;
        Integer num_b= 214748364;

        num_a= 214748364;

        //Getting sum of two Integer numbers
        sum_c = num_a + num_b;

     System.out.println("The sum of two Integer variables is = " + sum_c);
  }
}

Output:

Example of using Integer in ArrayList collection

As mentioned earlier, the Integers class can be used with generics. For example, if you want to create an ArrayList of int numbers, you can’t do it by using the primitive type int. As such, the generic types must be of type objects, so you may use the Integer there.

In the following example, an ArrayList is created with five numeric elements. The ArrayList is declared with Integer type, so the elements can be numbers only. This is how the Integer is used:

The ArrayList with integers:

import java.util.*;

public class java_variables {

    public static void main(String []args) {

        ArrayList<Integer> IntegerArrLst = new ArrayList<Integer>(); //Declaring ArrayList with Integer

        IntegerArrLst.add(5);
        IntegerArrLst.add(10);
        IntegerArrLst.add(15);
        IntegerArrLst.add(20);
        IntegerArrLst.add(25);

        //Displaying array list

        for (int IntgerArrItem : IntegerArrLst) {

                 System.out.println("The Integer item in ArrayList: " + IntgerArrItem);

              }
}           
}

The result:

If you try using the primitive type int in place of Integers in the above example, an error will be generated.

Similarly, you may use Integer in other collection types like vectors.

The Long class

For the long primitive type, the wrapper class in Java is Long. You may apply the same examples as used for the integer class in the above section; for larger values.