Bethan Palmer

Bethan is a Java developer and product manager for JPedal at IDRsolutions. She has spoken at conferences including JavaOne and NetBeans day and has a degree in English Literature.

Java 10 Local-Variable Type Inference Explained in 5 Minutes

1 min read

The biggest new feature in Java 10 is the introduction of the Local-Variable Type Interface.

What is Local-Variable Type Inference?

This new feature will allow you to declare and initialise local variables with var, rather than specifying a type. This feature is already a part of most other statically typed languages (It has been in C# since 2007).

For example, with Java 9 or earlier your code might look like this:

String greeting = "Hello World";
ArrayList<String> messages = new ArrayList<String>();
messages.add(greeting);
Stream<String> stream = messages.stream();

But in Java 10 you can do this:

var greeting = "Hello World";
var messages = new ArrayList<String>();
messages.add(greeting);
var stream = messages.stream();

Where you can use it:

  • local variables with initialisers
  • indexes in for each loops
  • locals in for loops

Where you cannot use it:

  • method formals
  • constructor formals
  • method return types
  • fields
  • catch formals

Basically, the only time you can use var is when initialising local variables and in for loops.

What are the pros?

Var helps to reduce the amount of boilerplate code needed to write Java. It makes the language less verbose, and the information about type is not duplicated.

For example in Java 7 you would do:

HashMap<HashSet<String>, ArrayList<String>> map = new HashMap<HashSet<String>, ArrayList<String>>();

In Java 8 the diamond operator was introduced and this was shortened to:

HashMap<HashSet<String>, ArrayList<String>> map = new HashMap<>();

In Java 10 you can now do:

var map = new HashMap<>();

What are the cons?

It could be argued that using var makes code less readable, as it may not be immediately obvious what the type is. In the example above the code is much more concise, but it is also less clear. You have to be more careful about giving variables names that make it obvious what they are for. And when you do not specify the type, you are essentially leaving it down to someone else to work out what it is.

Are you using var yet? Let us know your thoughts in the comments.

If you’re a first-time reader, or simply want to be notified when we post new articles and updates, you can keep up to date by social media (Twitter, Facebook and Google+) or the Blog RSS.

Bethan Palmer

Bethan is a Java developer and product manager for JPedal at IDRsolutions. She has spoken at conferences including JavaOne and NetBeans day and has a degree in English Literature.

Java 10’s Experimental JIT Compiler explained in 5 minutes

This month’s theme is Java 10 to tie in with the release of the new Java version. Despite being only 6 months since Java...
Georgia Ingham
1 min read

2 Replies to “Java 10 Local-Variable Type Inference Explained in 5 Minutes”

  1. Good explanation.

    But I think this is going backward when Java introduced the concept of mentioning the type of arguments for collections. Like Map kvm = new HashMap() to make it type safe. With introduction of var (even for local variables) they are some somewhat going backwards. Isn’t it?

    1. Hi Sanjay,
      Using var does make the code less explicitly typed, but I think it is worth the trade-off when considering how much cleaner the code looks

Leave a Reply

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