Modern Java syntax: var, text blocks and more

A new version of Java comes out every six months, and many of them add something small that makes everyday code shorter or easier to read. This lesson collects those additions in one place. Some are new to you: var, text blocks for text that runs over several lines, a few newer String methods, and the underscore _ for values you never use. Others you have met already, and here they work together in one program. A table at the end says which Java version brought each feature, so you know what you can use on an older Java at school or at work.

var: let the compiler write the type#

Here is the same variable from a bookshop program, declared three ways:

The first line names the type twice. The diamond from generics lets you drop the second copy. Since Java 10 you can drop the first copy instead, by writing var. It tells the compiler: work out this variable's type from the value on the right. The compiler sees new TreeMap<String, Integer>(), so stock gets exactly that type, the same as in the first line.

This is called local variable type inference. Inference means the compiler works the type out for itself. Local means it only works for local variables, the ones declared inside a method, which exist only while the method runs.

Step through it. On the first three lines the narration says Declare int copies, Declare double price and Declare String title, and the memory view shows each variable's type next to its name. The compiler read 3 as an int, 9.99 as a double and the text in quotes as a String. The loop variable entry is where var saves the most typing: its full type is Map.Entry<String, Integer>. The program prints Dune: 3, Emma: 5 and Dune costs 9.99, tags [sci-fi, classic].

The type is still fixed

var does not make a variable flexible. Once the compiler has picked a type, the variable keeps it for life, exactly as if you had written the type yourself. Try to put text into a variable that started out as a number:

That is the message you would get after int count = 10; as well. The static typing you met in variables and types works the same with or without var.

Key idea

var asks the compiler to copy the type from the starting value. The variable still has one fixed type, checked before the program runs, exactly as if you had written it out.

Where var works

You can use var wherever you declare a local variable and give it a value in the same statement:

• A local variable with a starting value: var total = 0;
• The counter of a for loop: for (var i = 0; i < 3; i++)
• The variable of an enhanced for loop: for (var entry : stock.entrySet())
• A resource in try-with-resources, from reading files: try (var br = new BufferedReader(new FileReader("notes.txt")))
• The parameters of a lambda, since Java 11: (var a, var b) -> a + b. Either every parameter uses var or none does.

The lambda form looks pointless, since (a, b) -> a + b already leaves the types out. It exists so that you can put an annotation on a lambda parameter without writing its type, and annotations are the subject of the next lesson.

Where var does not work

var needs a value to copy a type from. These are the two mistakes people make first:

The first error is about the missing starting value, which javac calls an initializer. int total; followed by total = 42; is fine, because the type is written down, but with var the compiler would have nothing to read the type from. The second error is about null. It means “no object”, and it says nothing about which kind of object might arrive later, so there is no type to copy.

A few more places where javac says no:

The braces of an array and the arrow of a lambda only make sense once Java knows the type they are for, so var cannot work it out from them. The last two rows show the other limit: var is only for local variables. Fields, parameters and return types are how a class talks to the rest of the program, so Java wants their types written where every reader can see them.

When var makes code harder to read

Code is read far more often than it is written, and var hides the type from the reader. That costs nothing when the right-hand side shows the type anyway. It hurts in three situations.

The first is a method call whose result is not obvious. In var result = library.search("dune");, is result one book, a list of books or an Optional? The reader has to go and find search to know. Writing List<Book> result answers the question on the spot, and so does a better name such as matchingBooks.

The second is a plain number. A whole number written without a decimal point is always an int, so var makes an int even when you meant something else. Decide what this prints before you run it.

It prints 2 and then 2.5. 10 made slices an int, so slices / friends is integer division, the surprise from operators and casting. 10.0 made price a double, and the division kept its half. With the types written out, int slices = 10; would have shown the problem at a glance.

The third is the diamond. In var names = new ArrayList<>(); nothing says what the list holds, so Java picks the most general type there is, Object, and names becomes an ArrayList<Object>. The mistake shows up later, far from its cause:

With var, put the type arguments on the right: var names = new ArrayList<String>();. Or keep the type on the left and the diamond on the right, as you did in generics. Here is a rule of thumb drawn from the guide the Java team wrote on using var:

Text blocks: text that keeps its shape#

Writing several lines of text in an ordinary string is fiddly. Every line needs a \n at the end and a + to join it to the next, and every quotation mark inside the text needs a backslash in front. Here is a short note to a friend written that way, and the same note as a text block:

A text block starts with three double quotes, """, and a line break. The text begins on the next line and runs until the closing """. Line breaks are real line breaks, and quotation marks need no backslash. The program prints the note and then true: both versions build exactly the same string.

A text block is just another way to write a String. It works anywhere a string in quotes would, and every String method works on it. Text blocks became a standard part of Java in Java 15, and they are the usual way to put SQL, JSON or HTML into a Java program.

Which spaces Java keeps#

In the source code, every line of that note starts with 16 spaces, which line it up with the code around it. None of those spaces reach the output: Java removes them on purpose. The designers of text blocks call them incidental white space, spaces that only come from where the code sits.

Java looks at every line that has text on it, and at the line of the closing delimiter when the delimiter stands on its own. It finds the smallest indentation among those lines and removes that many spaces from the start of every line. Any extra indentation a line has stays in the string. Then Java removes the spaces at the end of each line.

Breakfast, Lunch and the closing delimiter are the least indented lines, at 16 spaces, so Java removes 16 from every line. The dishes sit 4 spaces further in, and they keep those 4:

Key idea

Java removes the indentation that all the lines share, counting the closing delimiter's line when it stands alone, and the spaces at the end of each line. The rest of what you typed stays.

Where the closing delimiter goes#

Because the closing delimiter's line can count, where you put it changes the string:

• On its own line, lined up with the text, as in the menu. The string ends with a line break after the last line, and no extra indentation is kept.
• At the end of the last line of text, as in Soup""";. That line holds text, so only the text lines count, and the string ends right after Soup with no final line break.
• On its own line, further left than the text. Now it is the least indented line, so Java removes less, and every line keeps the difference. At the very start of its line, it makes Java remove nothing at all.

Further right than the text makes no difference, because the text lines are then the least indented. Try each position in the lab. It writes the block at the left edge of the code, so the numbers stay small: Breakfast and Lunch start 4 spaces in, the dishes 8.

Now check yourself on the two most common positions. The square brackets in the output show where each string starts and ends.

It prints five lines: [red, green], [red, green and a line holding only ]. The string a ends right after green, so its closing bracket follows at once. The string b ends with a line break, so its closing bracket lands on a line of its own.

Two escapes made for text blocks#

The usual escapes such as \t still work inside a text block, and two more are useful here:

• A backslash at the very end of a line joins that line to the next. It lets you keep a long sentence on short lines in your code without putting a line break into the string.
• \s stands for one space. Java translates escapes last, after it has removed the spaces at the ends of lines, so a \s at the end of a line protects the spaces in front of it, and then becomes a space itself.

The first text block prints as one line. In plain, the three spaces after Total are removed, even though you can see them in front of the closing delimiter. In kept, the two spaces in front of \s survive and \s adds a third, so three spaces sit before the closing bracket. Spaces at the end of a line matter in a few places, such as files where every line must be exactly the same length.

Filling in values with formatted#

A text block has no way to drop a variable straight into the text. Joining pieces with + works, but it chops up the shape you were trying to keep. The tidy way is the method formatted, added in Java 15 for this job. It works like String.format, called on the text itself: each blank, such as %s or %d, is filled in from the values you pass, in order.

%s takes guest, %d takes the whole number of nights, and %.2f takes the total and shows it with two decimal places, so the last line reads Total to pay: 268.50. "...".formatted(a, b) gives the same result as String.format("...", a, b). On a text block, formatted keeps the values right next to the text they fill.

1public class Main {
2    public static void main(String[] args) {
3        var title = "Dune";
4        var author = "Frank Herbert";
5        var days = 21;
6        var reader = "Ravi";
7 
8        // TODO: build the slip with a text block and formatted(...)
9        String slip = "";
10 
11        System.out.print(slip);
12    }
13}

Newer String methods#

Java 11 and the versions after it gave String a set of methods for jobs that used to need a loop. Like every String method, each one hands back a new value and leaves the original alone. You met three of them in strings: isBlank, repeat and strip. This section shows what strip does that trim does not, and adds the rest.

strip, stripLeading and stripTrailing

strip() removes white space from both ends, like trim(). Its two halves clean one end only: stripLeading() the start and stripTrailing() the end. The difference from trim() is what counts as white space.

The brackets show what each of the first three calls kept. The next two lines show the difference from trim(). \u3000 is the wide space used in Chinese and Japanese text. trim() only knows the ordinary space and the invisible control characters below it, so it leaves both wide spaces and the length stays 5. strip() removes every character Java counts as white space, so only the three letters of Ada remain: 3. The last two lines are the recap from strings: three spaces are not empty, so isEmpty() gives false, but they are blank, so isBlank() gives true.

repeat and lines

repeat(n) gives the string n times in a row, which is handy for dividing lines and bars in console output. lines() cuts a string at its line breaks and hands you the lines as a Stream<String>, without the line breaks, so every stream method from streams is ready to use.

It prints a row of 24 equals signs, then HaHaHa, then 4. The song has 4 lines: the empty line in the middle counts, and the line break at the very end only finishes the last line, so it does not start a fifth. The stream then drops the blank line and prints the other three in capitals.

indent and stripIndent

indent(n) moves every line n spaces to the right, or up to n spaces to the left when n is negative, and makes sure the result ends with a line break. stripIndent() runs the text block rule on any string: it removes the indentation that all the lines share, and the spaces at the ends of lines. That helps with text your program builds or reads, such as a quote copied out of an indented e-mail.

indent(4) pushes both recipe lines 4 spaces to the right and adds a line break after the second, which is why print is enough. indent(-6) takes 6 of the 8 spaces in front of Bake away. stripIndent() sees that both lines of the quote start with 8 spaces and removes all 8.

chars: the characters as numbers

chars() is older than the rest, from Java 8, and it surprises nearly everyone once. It returns an IntStream, a stream of int values, with one number for each character. Decide what this prints.

It prints 72, 105 and 33. A char is stored as a number, its code in the character table, as you saw in operators and casting, and chars() hands you those numbers. To turn one back into a character, cast it: (char) c. Often you do not need to, because comparing with a character such as c == 's' works on the numbers directly, and so do Character methods such as isDigit:

It prints 4, true and false. Counting one letter takes a single line, and so does checking that a PIN is made only of digits.

1public class Main {
2    public static void main(String[] args) {
3        String pasted = "  milk \n\n eggs\n   \n  bread  \nrice\n";
4 
5        int number = 0;
6        // TODO: go through pasted.lines().toList(), skip the blank lines,
7        // and print each item stripped and numbered: 1. milk, 2. eggs, ...
8 
9        System.out.println(number + " items");
10    }
11}

Switch, records and patterns in one program#

You have met three more of Java's newer features in earlier lessons. A switch expression produces a value, with yield for a case that needs several lines, from making decisions. A record holds plain data in one line, from records. Patterns test what kind of value you have and take it apart, and a sealed type closes the list of kinds, from sealed types and pattern matching. Modern Java code uses them together, so here they are in one program: a music app's queue of songs, podcasts and adverts.

The sealed interface Media says there are exactly three kinds of item, each a record. Read describe from the top:

• case Song(var title, var seconds) when seconds < 60 is a record pattern with a guard. It matches a song, unpacks its two components into variables, and takes only songs shorter than a minute.
• The next case takes every other song. It has to come after the guarded one, or it would take all songs and javac would reject the guarded case as dominated.
• The podcast case needs two lines, so its arrow leads to a block that ends with yield.
• case Ad _ is a type pattern without a name, because describing an advert needs nothing from inside it.
• There is no default. Media is sealed, so these cases cover every possible item, and javac checks that when it compiles the program.

The if at the end of main uses a record pattern with instanceof. Podcast(var show, _, var minutes) unpacks the show and the length and skips the episode number, and the test after && can use minutes because it only runs when the pattern matched. The program prints Clair de Lune, 5 min, A short song: Intro, Java Weekly #12, a long one, An advert and Save Java Weekly for the train.

The unnamed variable _#

You just saw _ twice: for the episode number nobody needed, and in place of a name for the advert nobody looked inside. Since Java 22, a single underscore can stand in for a variable that Java makes you declare but that you never read. It is called the unnamed variable, and it tells the reader that the value is unused on purpose. It works outside patterns too:

It prints Blue, Intro and Volume must be a number. forEach on a map hands its lambda two values, a key and a value. This one only prints titles, so the play count is _. A catch must declare its exception even when the block never uses it, so that is _ as well. The same goes for the variable of an enhanced for loop that only counts its turns. Three rules come with it:

• You cannot read _. System.out.println(_); stops javac with underscore not allowed here.
• One method can declare several, even side by side as in (_, _) -> 0, because none of them has a name to clash with.
• It is for local variables, lambda and catch parameters, and patterns. A field or a method parameter cannot be _.

Key idea

Write _ where Java makes you name something you will never read: a part of a pattern, a caught exception, a lambda parameter. The reader then knows it is unused on purpose.

Compact source files and helpful error messages#

Compact source files

Your very first program, in your first Java program, was a compact source file: a void main() with no class written around it, printing with IO.println. Java 25 made that form standard. Two more facts about it are useful now. A compact source file may declare records, classes and other methods next to main. And it can use every public class in Java's core library, the part called java.base that holds java.util, java.io and java.time, without a single import line. Here is a small program in that form that uses several features from this page:

It prints Items: 3 and Total: 4.64. List needed no import, and the record Item sits right in the file. The classic form you see everywhere else in this course still matters: real projects are made of many classes in many files, and compact files are meant for small programs like this one.

Helpful NullPointerException messages

In reading errors and debugging you read a message such as Cannot invoke "String.length()" because "last" is null. Java 14 added these detailed messages, and since Java 15 they are switched on by default. They help most in a chain of calls, where more than one value could be the null:

Grace has an address, so the first line prints Arlington. Ada's address is null, and the second line stops the program with this message: Cannot invoke "Address.getCity()" because the return value of "Customer.getAddress()" is null. It names both halves of the problem. The call that failed is getCity(), and the value it was called on was the null that getAddress() returned. Before Java 14 the exception carried no message at all, only a line number, and you had to work out for yourself which call was to blame. If a customer may really have no address, the Optional from the previous lesson says so in the type.

Which Java version brought what#

Since 2018 a new Java has come out every March and every September. A new language feature usually spends a version or more as a preview, which you have to switch on with the --enable-preview option, before it becomes a standard part of Java. The table lists the version where each feature became standard. The versions marked LTS get long-term support, so most companies run one of them. If your job uses Java 17, everything in the rows up to Java 17 works there, and nothing below it does.

Further reading#

• Using the Var Type Identifier, the dev.java tutorial on where var can and cannot go
• Local Variable Type Inference: Style Guidelines, the Java team's advice on when var helps the reader
• Programmer's Guide to Text Blocks, Oracle's guide to indentation, the closing delimiter and the escapes
• JEP 456: Unnamed Variables and Patterns, every place the underscore may go and why