Scalable Human Blog

One of the most significant enhancements introduced in Java 10 was the addition of local-variable type inference, which allows developers to declare local variables without specifying their type. In this blog post, we’ll explore the var keyword, which makes this feature possible, and delve into how it can streamline your Java code.

Understanding var in Java 10

In Java 10, the var keyword was introduced to infer the type of a local variable from its initialiser. Essentially, var lets the Java compiler infer the data type of the variable from the right side of the initialisation statement. Here’s an example:

var list = new ArrayList<String>(); // Inferred as ArrayList<String> var stream = list.stream(); // Inferred as Stream<String>

It’s essential to understand that var is not a new type. It’s just a placeholder for the compiler to infer the actual type.

When to Use var

The var keyword can be used to enhance the readability of your code when the type is evident from the context. Here are a few situations where var can be advantageous:

• When the type of the variable is quite verbose, such as in parameterized types.
• When you’re dealing with complex nested types.
• When the exact type doesn’t matter to the reader because it’s straightforward from the context.

Here’s an example where var improves code readability:

var entries = new HashMap<String, List<String>>().entrySet();

When Not to Use var

While var can simplify code, it shouldn’t be used indiscriminately. Here are some instances where using var might not be the best option:

• When the initializer doesn’t provide enough information to determine the variable’s type.
• When the inferred type is not what was intended, which could lead to subtle bugs.
• When the variable’s type is essential information for code readability.

For instance, in the below example, it’s not clear what type item is:

var item = getItem(); // It's not clear what type 'item' is.

Conclusion

The introduction of local-variable type inference in Java 10 with the var keyword has undoubtedly streamlined coding by reducing verbosity. However, while var can increase the succinctness and readability of code, it should be used judiciously. Understanding when and where to leverage var can help you craft more efficient and cleaner Java programs.

📚 Further Reading & Related Topics

If you’re exploring local variable type inference in Java 10, these related articles will provide deeper insights:

• Java 11 and the New var Keyword: Enhancing Readability and Reducing Boilerplate Code – Learn how the varkeyword introduced in Java 10 continues to improve code readability, reduce verbosity, and simplify development.

• Mastering Java 16’s Pattern Matching for Instanceof: Simplifying Conditional Extractions – Discover how pattern matching for instanceof enhances type checking and simplifies conditional logic, further improving Java’s syntax and developer experience.