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.

// 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:

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.

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

Master Java with Deep Grasping Methodology!

Learn More