The var Identifier (Java 10 and Later)


Java 10 was first released in Mar 2018 and its language update can be considered quite new at the time of this writing.  An important part of the release was about the new var identifier.

According to the Oracle's Java release document, "you can declare local variables with non-null initializers with the var identifier."

Consider this example of declaring a variable with an assignment of a non-null initializer:
URL url = new URL ("http://www.amazon.com/");

Instead of specifying the Class or primitive type before a variable, with Java 10 or later we can declare the variable by using the var identifier:
var url = new URL ("http://www.amazon.com/");

The Class of the new variable url is automatically inferred from the context. Declaring the datatype before the variable is no longer necessary.

Now consider the variables that I declared with a generic class type in my earlier post:
GenericArrayStat <Integer> numHousesSold = new GenericArrayStat <> (iNumArray);
GenericArrayStat <Integer> soldPrices = new GenericArrayStat <> (dNumArray);

By using the var identifier, we can shorten the declarations in this way:
var numHousesSold = new GenericArrayStat <Integer> (iNumArray);
var soldPrices = new GenericArrayStat <Double> (dNumArray);

While the var identifier looks convenient for the assignments of new objects, it possibly requires you to pay more attention to the assignments of existing ones.

Consider these declarations in the traditional way that the Class or primitive type are clearly defined in the code:
Path filePath = Paths.get(fileName);
bytes[] fileBytes = Files.readAllBytes(filePath);

Now compare the new var declarations with above:
var filePath = Paths.get(fileName);            // infers Path
var fileBytes = Files.readAllBytes(filePath);  // infers bytes[]

By using var declarations, we can see that the class and primitive type of the assigned variables are not included in this case.  However, we have the option to include them in the comments.

In recent years, there have been newer languages aiming at simplifying language verbosity.  It is good that Java provides with the flexibility on how to code.  We want just enough meaning in the code, and we want consistency.  Choose the way you like.

Comments

Post a Comment

Popular posts from this blog

Finding Median by Stream

Image
This small waterfall is one of the many intermediate operations of the stream. Photo taken in Algonquin, ON The Java's DoubleStream class provides a few methods for common statistics including min(), max(), sum(), and average().  For average(), what does it actually mean?  Here is the description in the specification: The average() method returns an OptionalDouble describing the arithmetic mean of elements of the stream, or an empty optional if the stream is empty. While the arithmetic mean method is handy, we likely want a median method for different needs as well.  The DoubleStream class doesn't provide a median() method but the sorted() method.  We can use the sorted() method to assist in finding the median value. Building the Median Function Given each of existing min(), max(), and average() will return an OptionalDouble, having a median() method to return the same type is preferable.  There are different ways to create a median method, and the goal here is ...
Read more

Factorial by Different Styles in Java

Here is a collection of methods of calculating factorial by different programming styles. class Factorial { // Iteration static long iterativeFactorial( int n) { long r = 1; for ( int i=1; i<=n; i++) r*=i; return r; } // Recursion static long recursiveFactorial( int n) { return n == 0 ? 1 : n * recursiveFactorial(n-1); } // Tail-recursion static long tailRecurFactorial( int n) { return tailRecurHelper(1L, n); } static long tailRecurHelper( long acc, int n) { return n == 0 ? acc : tailRecurHelper(acc*n, n-1); } // Lambda and Recursion static Function<Integer, Long> lambdaRecurFactorial = x -> x==0 ? 1L : x * Factorial.lambdaRecurFactorial.apply(x-1); // Stream static long streamFactorial ( int n) { return LongStream.rangeClosed(1, n) .reduce(1, (a, b) -> a*b); } /...
Read more

Reduction by Java Stream

For business analysis, it is often useful to reduce a list of numbers to a single value. "What is the sum of product A sold among all the invoices?" "What is the median price among all the houses sold in Toronto last month?" "What is the average annual inflation over the last 10 years?" This type of queries is reduction operation that can be handled by the Stream class.  Below are some examples to help memorizing how the reduce  method is used. Here are three different functions of calculating the sum of a list of integers. The first function is a typical for-loop.  The second and third produce the same result by using stream's reduce . Compare the functions for mnemonic.  List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 12, 14, 16); Function<List<Integer>, Integer> sumMethod1 = (numbers) -> { int sum = 0; for (Integer x : numbers) sum += x; return sum; }; System.out.println ( "sum = " + sumMethod1.apply(l...
Read more