`var` Keyword & Type Inference (Java 10+)

The var keyword was introduced in Java 10 to support local variable type inference. It helps make Java code cleaner, shorter, and easier to read, especially when working with complex data types.

What is `var` in Java?

The var keyword allows the Java compiler to automatically determine the type of a variable based on the value assigned to it.

In simple words: You don’t need to explicitly write the data type — Java automatically figures it out at compile time.

Example

var number = 10;          // int
var name = "Durgesh";     // String
var price = 99.99;        // double

In this example:

number is treated as int
name is treated as String
price is treated as double

Local Variable Type Inference

Local variable type inference means the Java compiler automatically detects the variable type based on the assigned value.

Example:

var name = "Java";
var age = 25;
var price = 99.99;

? Internally, Java treats it as:

String name = "Java";
int age = 25;
double price = 99.99;

Type is decided at compile time
No extra cost at runtime (no overhead)
Java still remains a statically typed language

Why Use `var`?

The var keyword is useful when working with complex data types, especially in modern Java applications. It helps reduce unnecessary code and makes programs easier to read and write. Instead of repeating long type declarations, developers can rely on the compiler to infer the type automatically. It is particularly helpful when dealing with generics, collections, and streams, where type declarations can become lengthy and harder to maintain.

Before Java 10:

In older versions of Java, developers had to explicitly mention the full type, even if it was long and repetitive.

Map<String, List<Integer>> map = new HashMap<>();

With var:

With Java 10, we can use var to let the compiler infer the type automatically.

var map = new HashMap<String, List<Integer>>();

Benefits:

Using var provides several advantages in modern Java development:

Reduces boilerplate code – Less typing and cleaner syntax
Improves readability – Easier to understand, especially with complex types
Cleaner and modern code – Follows modern Java coding practices

How `var` Works

The type is automatically inferred at compile time based on the assigned value
Once the type is assigned, it cannot be changed later
The compiler internally replaces var with the actual data type
It behaves like a normal variable, so Java remains statically typed

Example:

var x = 10;   // int
x = 20;       //  allowed
x = "Hello";  //  error

Rules of Using `var`

There are some important rules you must follow when using the var keyword in Java.

1. Must Be Initialized

var must be initialized at the time of declaration
Cannot declare without a value

var x = 10;   //  valid
var y;        //  error

? Compiler needs a value to infer type.

2. Only for Local Variables

Allowed inside:
- Methods
- Loops
- Blocks
Not allowed as instance or class variables

class Test {
    var x = 10;   //  error (not allowed here)
}

3. Cannot Use with `null` Alone

var cannot be used with null only

var x = null;   //  error

? Because the compiler cannot determine the type.

4. Type Cannot Change

Once type is assigned, it is fixed
Cannot assign a different type later

var x = 10;
x = "Hello";   //  invalid

5. Cannot Be Used Without Assignment

Declaration without assignment is not allowed

var x;   //  invalid

6. Not Allowed for Method Parameters or Return Types

Cannot be used in method parameters or return types

public var method() { }   //  invalid
void show(var x) { }      //  invalid

Using `var` with Collections

Using var with collections makes the code shorter and easier to read, especially when working with generics.

Example with var

var list = new ArrayList<String>();
list.add("Java");

Without var

ArrayList<String> list = new ArrayList<>();

Using `var` in Loops

var can be used in loops to simplify variable declaration and improve readability.

for (var i = 0; i < 5; i++) {
    System.out.println(i);
}

? The compiler automatically treats i as an int, so you don’t need to declare the type.

Using `var` with Streams

var is also useful when working with streams, where types can become complex.

var names = List.of("Ram", "Shyam", "Amit");

names.stream()
     .forEach(n -> System.out.println(n));

? Using var makes the code cleaner and easier to read, especially with collections and streams.

Advantages of `var`

Reduces boilerplate code – No need to repeatedly write long type declarations
Improves readability – Makes complex generic types easier to understand
Cleaner and concise syntax – Code looks shorter and more modern
Maintains type safety – Java is still statically typed (no dynamic typing)
Works well with Streams & Collections – Simplifies code when dealing with complex return types

Limitations of `var`

Can reduce readability if overused – Too much use of var can make code confusing
Type is not explicitly visible – You cannot see the type directly from the declaration
Only works for local variables – Cannot be used for instance variables or method parameters
Not suitable when type is unclear – Avoid using var when the assigned value does not clearly indicate the type

Best Practices for Using `var`

Using var correctly can make your code cleaner, but misuse can reduce readability. Follow these best practices:

Use When Type is Obvious Use var when the type can be easily understood from the value

var count = 10;

Use for Complex Generic Types

Helpful when working with long and complex type declarations

var map = new HashMap<String, List<Integer>>();

Use in Loops

Makes loop variables simpler and cleaner

for (var item : list) {
    System.out.println(item);
}

Avoid When Type is Unclear

Do not use var if the type is not obvious from the method

var data = getData();   //  unclear type

Avoid Overuse

Using var everywhere can reduce readability

var a = 10;
var b = 20;
var c = a + b;

? Too much use of var can make code harder to understand.

Difference Between `var` vs Dynamic Typing

Feature	`var` (Java)	Dynamic Typing
Type checking	Done at compile time	Done at runtime
Type safety	Strong (errors caught early)	Weak (errors at runtime)
Type change	Not allowed	Allowed
Language type	Statically typed	Dynamically typed

? Java is still statically typed, even with var.

Real-World Use Cases

Working with collections – Simplifies long generic type declarations
Stream API operations – Makes stream-related code cleaner and more readable
Complex generic declarations – Avoids writing lengthy types repeatedly
Loop variables – Useful in for and enhanced for-loops
Cleaner modern Java code – Helps write concise and maintainable code

Conclusion

The var keyword in Java helps make code shorter, cleaner, and more modern by enabling local variable type inference. It reduces unnecessary type declarations while keeping Java’s strong type system intact.

Reduces boilerplate code
Helps write concise and readable code
Maintains strong type safety (compile-time checking)

? When used properly, var improves code quality and developer productivity. However, overusing it can reduce readability, so it should be used wisely.

var Keyword & Type Inference (Java 10+)

What is var in Java?

Local Variable Type Inference

Why Use var?

How var Works

Rules of Using var