long

The long keyword in Java designates a 64-bit signed two’s complement integer primitive data type. It provides a significantly larger numerical range than the standard 32-bit int type, allocating 8 bytes of memory per variable.

Technical Specifications

• Memory Size: 64 bits (8 bytes)
• Minimum Value: $-2^{63}$ (-9,223,372,036,854,775,808), accessible via Long.MIN_VALUE
• Maximum Value: $2^{63}-1$ (9,223,372,036,854,775,807), accessible via Long.MAX_VALUE
• Default Value: 0L (when declared as a class or instance variable)
• Wrapper Class: java.lang.Long (used for generics and utility methods)

Syntax and Literals

By default, Java interprets unadorned integer literals as int. To explicitly define a long literal, you must append the suffix L or l to the number. The uppercase L is the universally accepted standard, as the lowercase l is visually indistinguishable from the digit 1 in many fonts.

// Standard declaration
long defaultLong;

// Initialization with the 'L' suffix
long exactLong = 5000000000L;

// The suffix is strictly required if the literal exceeds the 32-bit int limit (2,147,483,647)
// long invalidLong = 5000000000; // Compilation error: integer number too large

// Java 7+ allows underscores for digit grouping to improve readability
long readableLong = 9_223_372_036_854_775_807L;

long variables also support alternative base representations:

// Hexadecimal literal (prefix 0x)
long hexLong = 0x7FFF_FFFF_FFFF_FFFFL;

// Binary literal (prefix 0b)
long binaryLong = 0b1111_0000_1010_0101L;

// Octal literal (prefix 0)
long octalLong = 0777L;

Type Casting

Because long occupies a larger memory footprint than byte, short, or int, Java performs implicit widening conversions. Conversely, converting a long down to a smaller integer type requires an explicit narrowing cast, which truncates the upper 32 bits and may result in data loss or sign inversion.

// Implicit Widening (int -> long)
int standardInt = 1024;
long widenedLong = standardInt; 

// Explicit Narrowing (long -> int)
long massiveLong = 3_000_000_000L;
int narrowedInt = (int) massiveLong; // Results in -1294967296 due to bit truncation

Concurrency and Atomicity

In the Java Memory Model (JMM), read and write operations on 64-bit long primitives are not guaranteed to be atomic on 32-bit architectures. The JVM may execute a 64-bit operation as two separate 32-bit operations, potentially exposing a partially updated state (word tearing) to other threads.

To guarantee atomic reads and writes across all architectures, a long must be declared with the volatile modifier, or managed via the java.util.concurrent.atomic.AtomicLong class.

// Guarantees atomic read/write operations in a multithreaded environment
private volatile long threadSafeLong;

Master Java with Deep Grasping Methodology!

Learn More