# What Data Type Is a Long?

//

Scott Campbell

The long data type in Java is used to store 64-bit signed integers. It is primarily used when we need to work with large whole numbers that are outside the range of the int data type. In this article, we will explore the characteristics and usage of the long data type in Java.

## Declaration and Initialization

To declare a variable of type long, we use the keyword long followed by the variable name. Here’s an example:

``````
long distance;
```
```

We can also initialize a long variable at the time of declaration:

``````
long population = 789_654_321L;
```
```

Note that a suffix L or l is appended to indicate that it is a long literal.

## Range and Size

The long data type can store integer values ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 (inclusive). This makes it suitable for dealing with very large numbers.

A long variable occupies 8 bytes (64 bits) of memory space in Java’s memory model.

## Usage Examples

The primary use case for the long data type is when we need to work with large whole numbers beyond the range of int. Some examples include:

• Storing timestamp values: When working with timestamps that represent dates far in the future or past.
• Calculating astronomical distances: For measuring astronomical distances such as light-years or distances between celestial bodies.
• Working with very large numbers: For performing mathematical operations on numbers that exceed the range of int.

For example, consider calculating the factorial of a large number:

``````
long factorial = 1;
int n = 20;

for (int i = 1; i <= n; i++) {
factorial *= i;
}

System.out.println("Factorial of " + n + " is: " + factorial);
```
```

In this example, using a long variable ensures that we can store the result of calculating the factorial even for larger values of n.

## Summary

The long data type in Java is used to store 64-bit signed integers. It is suitable for working with very large whole numbers beyond the range of int.

The range of values it can hold is from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. When declaring a long variable, we use the keyword long followed by the variable name. Initialization can be done at the time of declaration by assigning a value and suffixing it with L or l.

Overall, understanding the long data type and its capabilities allows us to handle larger numerical values in our Java programs efficiently.