> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java 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.
```java theme={"dark"}
// 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:
```java theme={"dark"}
// 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.
```java theme={"dark"}
// 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.
```java theme={"dark"}
// Guarantees atomic read/write operations in a multithreaded environment
private volatile long threadSafeLong;
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
