Local Variable Type Inference

Local variable type inference: detective with the label "compiler" using a magnifying glass to inspect a red block labeled "local variable"

This week we’re going to look at local variable type inference. The goal of this was to extend the type inference mechanism to local variable declarations with initializers. This was a preview language feature in JDK 10, and is now permanent.

Local variable type inference introduces a var reserved type name. We can use var instead of specifying an exact data type. The var type name is used on the left side of an assignment statement. The compiler automatically infers the correct data type from the right side of the assignment.

Simple Example of Local Variable Type Inference

Using the var type name means that instead of doing the following inside a method:

String name = "Rumpelstiltskin";

We can just type:

var name = "Rumpelstiltskin";

The compiler infers that name is a String and is equivalent to the previous version, but just with less typing.

This does not break static typing. The name variable is a String, and as such we will not be allowed to assign an int to it:

name = 1234;  // compiler error!

More Examples of Local Variable Type Inference

We’re already aware of type inference as far as generic types are concerned. Instead of specifying types on both sides of the assignment operator, we can use the type inference (diamond) operator and omit the second type declaration:

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

We often create local variables as “throw-away” variables – variables used as a temporary step towards creating another variable or result. It would be nice to reduce extra coding (and thought) by removing possibly unnecessary local variable type declarations.

We are familiar with code similar to the following:

// list is a throw-away variable
ArrayList<String> list = new ArrayList<>();   
Stream<String> stream = list.stream();

Local variable type inference allows us to create simpler code as follows:

// list is inferred as type ArrayList<String>
var list = new ArrayList<String>();    
// stream is inferred as type Stream<String>
var stream = list.stream();            
// sum is inferred as type int
var sum = stream.mapToInt(String::length).sum(); 
// extra code...

list.add("Hello, world"!);

Consumer<String> reader = s -> {
   // data is inferred as type String[]
   var data = s.split("\\s+");        
   // use data appropriately...

Here’s another example of a chained / throw-away variable:

var path = Paths.get(fileName);
var bytes = Files.readAllBytes(path);

Usage Restrictions

The identifier var is a reserved type name, and not a keyword. Any Java code that uses var as an identifier for variables, method names or package names will compile. Code that uses var as an interface or class name must be changed (but probably should have been changed anyway because those names violate the standard naming conventions).

We can use var when we create local variable declarations with initializers. We can also use var for index variables in both normal for loops and enhanced for-each loops.

We cannot use var for fields, constructor/method formal parameters, method return types, catch formal parameters, or any other kind of variable declaration.

Local variable declarations that do not have initializers, or that declare multiple variables, or have extra array dimension brackets, or reference the variable being initialized are not allowed.

If the initializer has the null type, a compiler error occurs. Like a variable without an initializer, this variable is probably intended to be initialized later, and the compiler doesn’t know what type we will use later.

For more information about var, see JEP 286: Local-Variable Type Inference.

As always, please share your comments and questions

Leave a Comment

Your email address will not be published. Required fields are marked *

Code like a Java Guru!

Thank You

We're Excited!

Thank you for completing the form. We're excited that you have chosen to contact us about training. We will process the information as soon as we can, and we will do our best to contact you within 1 working day. (Please note that our offices are closed over weekends and public holidays.)

Don't Worry

Our privacy policy ensures your data is safe: Incus Data does not sell or otherwise distribute email addresses. We will not divulge your personal information to anyone unless specifically authorised by you.

If you need any further information, please contact us on tel: (27) 12-666-2020 or email info@incusdata.com

How can we help you?

Let us contact you about your training requirements. Just fill in a few details, and we’ll get right back to you.

Your Java tip is on its way!

Check that incusdata.com is an approved sender, so that your Java tips don’t land up in the spam folder.

Our privacy policy means your data is safe. You can unsubscribe from these tips at any time.