Type inference was introduced in Java 10 with the new var keyword, enabling developers to declare local variables without explicitly specifying their type. This feature can help create cleaner, more concise code by reducing boilerplate, though it should be used judiciously to maintain code readability.

Here’s a guide on how to use type inference effectively and write cleaner code in Java 10 and later:

---

1. Use var for Local Variables

The var keyword allows you to declare local variables without explicitly stating their type. The compiler infers the type based on the expression assigned to the variable. Here’s how it works:

Example:

var message = "Hello, World!"; // Compiler infers this as String
var count = 42;                // Compiler infers this as int
var list = new ArrayList<String>(); // Compiler infers this as ArrayList<String>

System.out.println(message);  // Hello, World!
System.out.println(count);    // 42

Benefits:

• Eliminates redundancy. For instance:

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

becomes:

var list = new ArrayList<String>();

---

2. Use var in Loops

In for-each loops and traditional for-loops, var can simplify the code:

Example:

var numbers = List.of(1, 2, 3, 4, 5);
for (var num : numbers) {
    System.out.println(num); // Iterates through the numbers
}

Benefits:

• Avoids unnecessary type declarations while maintaining readability.

---

3. Use var with Streams and Lambdas

var integrates well with Java Streams and Lambda expressions to reduce verbosity:

Example:

var numbers = List.of(1, 2, 3, 4, 5);
var result = numbers.stream()
                    .filter(n -> n % 2 == 0)
                    .map(n -> n * 2)
                    .toList();

System.out.println(result); // [4, 8]

When working with complex streams, var can make code shorter and easier to follow.

---

4. Restrictions on var

While var is versatile, there are some limitations and rules:

• Only for Local Variables: var can only be used for local variables, loop variables, and indexes, not for class fields, method parameters, or return types.
• Compiler Must Infer Type: You must assign a value to a var. For example, the following won’t work:

var uninitialized; // Error: cannot use 'var' without initializer

• Anonymous Classes: Avoid overuse with anonymous classes to maintain clarity.

---

5. Maintain Readability

While var can simplify code, readability should always be a priority. Overusing var can obscure the code’s intent, especially when dealing with complex types:

Example of Overuse:

var map = new HashMap<List<String>, Set<Integer>>(); // Hard to understand

In such cases, it’s better to use explicit types.

---

6. Good Practices

• Use var for Obvious Types:

var name = "John Doe"; // Obviously String

• Avoid var for Ambiguous Types:

// Original:
var data = performOperation(); // What is the return type?
// Better:
List<String> data = performOperation();

• Avoid Excessive Chaining:

  Using var with complex chains can make debugging harder. Be explicit when needed.

---

7. Refactoring Example

Here’s how you can refactor code for better clarity using var:

Before Refactoring:

ArrayList<String> names = new ArrayList<>();
HashMap<String, Integer> nameAgeMap = new HashMap<>();

After Refactoring:

var names = new ArrayList<String>();
var nameAgeMap = new HashMap<String, Integer>();

This is concise without sacrificing clarity.

---

Conclusion

Type inference with var in Java 10 improves code conciseness and readability when used appropriately. To ensure cleaner code:

• Use var for obvious and readable scenarios.
• Avoid using var when the inferred type is unclear or ambiguous.
• Focus on balancing conciseness with the need for maintainable and self-explanatory code.