> ## 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 Greater Than
The `>` (greater than) operator is a binary relational operator that compares two numeric operands. It evaluates to a `boolean` value, returning `true` if the left-hand operand is strictly greater in mathematical value than the right-hand operand, and `false` otherwise.
```java theme={"dark"}
operand1 > operand2
```
## Operand Compatibility
The `>` operator is strictly limited to numeric types. It cannot be applied to `boolean` primitives, `String` objects, or standard object references.
* **Primitive Numerics:** Compatible with `byte`, `short`, `char`, `int`, `long`, `float`, and `double`. When applied to `char`, Java evaluates the underlying 16-bit unsigned integer (UTF-16 code point) of the character.
* **Wrapper Classes:** Compatible with numeric wrapper classes (e.g., `Integer`, `Double`, `Character`). The Java compiler applies auto-unboxing to extract the underlying primitive values before performing the comparison. If the wrapper object reference is `null`, attempting to evaluate it with the `>` operator will throw a `NullPointerException` at runtime during the unboxing process.
## Type Promotion
If the two operands are of different numeric types, or if they are sub-integer types, Java applies **binary numeric promotion** according to the Java Language Specification before evaluating the expression:
1. If either operand is of type `double`, the other is promoted to `double`.
2. Otherwise, if either operand is `float`, the other is promoted to `float`.
3. Otherwise, if either operand is `long`, the other is promoted to `long`.
4. Otherwise, **both** operands are automatically promoted to `int`.
This means if you compare a `byte` and a `short`, both are promoted to `int` prior to comparison; the `byte` is not simply widened to match the `short`.
```java theme={"dark"}
int a = 5;
double b = 4.5;
boolean result1 = a > b; // 'a' is promoted to 5.0 before comparison. Evaluates to true.
byte c = 10;
short d = 5;
boolean result2 = c > d; // Both 'c' and 'd' are promoted to int before comparison.
```
## Floating-Point Mechanics (IEEE 754)
When evaluating floating-point numbers (`float` and `double`), the `>` operator adheres to IEEE 754 standards, which introduces specific behavioral rules:
* **NaN (Not a Number):** If either or both operands are `NaN` (e.g., `Double.NaN`), the `>` operator strictly evaluates to `false`.
* **Infinity:** `POSITIVE_INFINITY` is considered greater than any finite number and `NEGATIVE_INFINITY`.
* **Signed Zeros:** Positive zero (`0.0`) and negative zero (`-0.0`) are considered mathematically equal. Therefore, `0.0 > -0.0` evaluates to `false`.
## Syntax Visualization
```java theme={"dark"}
// Standard primitive comparison
boolean check1 = 10 > 5; // true
// Character comparison (evaluates ASCII/UTF-16 integer values: 98 > 97)
boolean check2 = 'b' > 'a'; // true
// Auto-unboxing evaluation
Integer objVal = 50;
boolean check3 = objVal > 25; // true (objVal is unboxed to int 50)
// NullPointerException during auto-unboxing
Integer nullVal = null;
// boolean check4 = nullVal > 0; // Throws NullPointerException at runtime
// Floating-point edge cases
boolean check5 = 5.0 > Double.NaN; // false
boolean check6 = 0.0 > -0.0; // false
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
