> ## 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 float
The `float` data type in Java is a single-precision 32-bit IEEE 754 floating-point primitive. It is designed to represent fractional numbers, allocating memory into three distinct components: a 1-bit sign, an 8-bit exponent, and a 23-bit mantissa (fraction).
## Technical Specifications
* **Memory Size:** 32 bits (4 bytes)
* **Default Value:** `0.0f`
* **Precision:** 6 to 7 significant decimal digits
* **Minimum Positive Non-zero Value:** `1.4E-45f` (`Float.MIN_VALUE`)
* **Maximum Value:** `3.4028235E38f` (`Float.MAX_VALUE`)
* **Wrapper Class:** `java.lang.Float`
## Syntax and Initialization
In Java, floating-point literals default to the 64-bit `double` type. To explicitly declare a `float` literal, you must append the `f` or `F` suffix. Omitting the suffix results in a compilation error due to a lossy conversion from `double` to `float`.
```java theme={"dark"}
// Standard declaration using the 'f' suffix
float pi = 3.14159f;
// Declaration using the 'F' suffix
float gravity = 9.81F;
// Scientific notation
float mass = 5.972e24f;
// Explicit casting from double (when suffix is omitted)
float threshold = (float) 0.005;
```
## Special Values
The IEEE 754 standard defines specific bit patterns for non-standard numerical states. Java exposes these through constants in the `Float` wrapper class:
```java theme={"dark"}
float positiveInfinity = 1.0f / 0.0f; // Evaluates to Float.POSITIVE_INFINITY
float negativeInfinity = -1.0f / 0.0f; // Evaluates to Float.NEGATIVE_INFINITY
float notANumber = 0.0f / 0.0f; // Evaluates to Float.NaN
```
## Type Conversion and Casting
`float` participates in Java's primitive type promotion and casting rules:
* **Widening (Implicit):** `float` can be implicitly promoted to `double`.
* **Narrowing (Explicit):** Converting a `double` to a `float` requires an explicit cast, which truncates the mantissa and rounds the value, potentially resulting in precision loss or `Infinity` if the value exceeds `Float.MAX_VALUE`.
* **Integer to Float:** `long` (64-bit) and `int` (32-bit) can be implicitly converted to `float`. However, because `float` only has 23 bits of precision for the mantissa, converting large integers may result in a loss of least significant digits.
```java theme={"dark"}
int largeInt = 16777217;
float fromInt = largeInt;
// fromInt becomes 16777216.0f due to precision truncation
double preciseDouble = 3.14159265359;
float narrowedFloat = (float) preciseDouble;
// narrowedFloat becomes 3.1415927f
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
