Java int Keyword
Usage and Examples

int Keyword in Java

The int keyword in Java is used to declare variables that hold integer values—whole numbers without decimal places. It is one of the most commonly used primitive data types in Java and serves as a foundational building block for many applications, from simple loops to complex algorithms.

Why Use int?

Java offers multiple numeric data types like byte, short, int, and long. Among them, int strikes a balance between memory usage and range. It occupies 4 bytes (32 bits) and is often the default choice for numeric values in most business logic and algorithmic scenarios.

Syntax of int

int variableName = value;

Here, int is the data type, variableName is the identifier, and value is the integer being assigned.

Examples: Declaring and Using int Variables

Example 1: Basic Declaration

public class Main {
  public static void main(String[] args) {
    int age = 25;
    System.out.println("Age is: " + age);
  }
}

Age is: 25

Explanation: We declared an int variable named age and assigned it the value 25. The value is printed using string concatenation.

Example 2: Arithmetic with int

public class Calculator {
  public static void main(String[] args) {
    int a = 10;
    int b = 5;
    int sum = a + b;
    int product = a * b;
    System.out.println("Sum: " + sum);
    System.out.println("Product: " + product);
  }
}

Sum: 15
Product: 50

Explanation: You can perform arithmetic directly using int variables. Here we added and multiplied two int values.

Memory and Range of int

The int type occupies 4 bytes (32 bits) and can represent values in the range:

-2,147,483,648 to 2,147,483,647

Example 3: Maximum and Minimum int Values

public class IntLimits {
  public static void main(String[] args) {
    System.out.println("Max int: " + Integer.MAX_VALUE);
    System.out.println("Min int: " + Integer.MIN_VALUE);
  }
}

Max int: 2147483647
Min int: -2147483648

Explanation: Java provides constants through the Integer class that expose the maximum and minimum values an int can hold.

Overflow and Underflow in int

Example 4: Overflow

public class OverflowExample {
  public static void main(String[] args) {
    int large = Integer.MAX_VALUE;
    System.out.println("Before overflow: " + large);
    large = large + 1;
    System.out.println("After overflow: " + large);
  }
}

Before overflow: 2147483647
After overflow: -2147483648

Explanation: Adding 1 to the maximum value causes overflow and wraps the value to the minimum.

Best Practices

• Use int instead of long unless you're sure the number will exceed 2 billion.
• When working with large datasets, choose int to optimize memory usage.
• Be cautious of overflow in loops or counters; use conditional checks when necessary.

When Not to Use int

• When you need decimal precision — use float or double.
• For smaller values (e.g., byte-level data), consider using byte or short.
• If values exceed the range of int, switch to long.