Java Downloads
JDK 20 is the latest release of Java SE Platform and JDK 17 LTS is the latest long-term support release for the Java SE platform.
JDK Development Kit 20.0.1 downloads
JDK 20 binaries are free to use in production and free to redistribute, at no cost, under the Oracle No-Fee Terms and Conditions.
JDK 20 will receive updates under these terms, until September 2023 when it will be superseded by JDK 21.
- Linux
- macOS
- Windows
Release information
- Online Documentation
- Installation Instructions
- Release Notes
- Documentation License
- JDK 20 Licensing Information User Manual (includes third-party licenses)
- Certified System Configurations
- Readme
JDK Development Kit 17.0.7 downloads
JDK 17 binaries are free to use in production and free to redistribute, at no cost, under the Oracle No-Fee Terms and Conditions.
JDK 17 will receive updates under these terms, until September 2024, a year after the release of the next LTS.
- Linux
- macOS
- Windows
Release information
- Online Documentation
- Installation Instructions
- Release Notes
- Documentation License
- JDK 17 Licensing Information User Manual (includes third-party licenses)
- Certified System Configurations
- Readme
JDK Script-friendly URLs
The URLs listed above will remain the same for JDK update releases to allow their use in scripts.
Protect your investment—and more
Java SE subscribers get support for JDK 17, receive updates until at least October 2029, are entitled to GraalVM Enterprise, Java Management Service, and bundled patch releases (BPRs) with fixes not yet available to nonsubscribers, and more.
Java SE subscribers have more choices
Also available for development, personal use, and to run other licensed Oracle products.
- Java 8
- Java 8 Enterprise Performance Pack
- Java 11
Java SE Development Kit 8u371
Java SE subscribers will receive JDK 8 updates until at least December 2030.
The Oracle JDK 8 license changed in April 2019
The Oracle Technology Network License Agreement for Oracle Java SE is substantially different from prior Oracle JDK 8 licenses. This license permits certain uses, such as personal use and development use, at no cost — but other uses authorized under prior Oracle JDK licenses may no longer be available. Please review the terms carefully before downloading and using this product. FAQs are available here.
Commercial license and support are available for a low cost with Java SE Universal Subscription.
Which Version of JDK Should I Use?
To build and run Java applications, a Java Compiler, Java Runtime Libraries, and a Virtual Machine are required that implement the Java Platform, Standard Edition (“Java SE”) specification.
The OpenJDK is the open source reference implementation of the Java SE Specification, but it is only the source code. Binary distributions are provided by different vendors for a number of supported platforms. These distributions differ in licenses, commercial support, supported platforms, and update frequency.
This site gives independent, yet opinionated recommendations.
✅ Recommendation: Use Adoptium Eclipse Temurin 17 and ensure that your local version matches the CI and production version.
Make sure, you have the latest patch level 17.0.3 or later, due to CVE-2022-21449.
Releases
Under the current JDK release model, a new feature release with a new major version number is planned every six months, in March and September. Additionally, there are quarterly bug fix updates.
Every three years, the September release will be a Long-Term-Support (LTS) release, which gets updates for at least three years.
| JDK Version | Type | Release Date | Highlights | Recommendation |
|---|---|---|---|---|
| 8 | LTS | 03/2014 | Lambdas | Last LTS version under previous release model. Free updates by Oracle ended, but still maintained by others. Upgrade to a 11 or 17 within the next months! |
| 9 | Feature | 09/2017 | Modules | New release model was introduced. EOL. Upgrade to 11 or 17 now! |
| 10 | Feature | 03/2018 | var | EOL. Upgrade to 11 or 17 now! |
| 11 | LTS | 09/2018 | New HTTP Client | Widely used LTS version. Plan upgrade to version 17 within the next months. |
| 12 | Feature | 03/2019 | EOL. Upgrade to 17 now! | |
| 13 | Feature | 09/2019 | EOL. Upgrade to 17 now! | |
| 14 | Feature | 03/2020 | Switch expressions | EOL. Upgrade to 17 now! |
| 15 | Feature | 09/2020 | Text blocks | EOL. Upgrade to 17 now! |
| 16 | Feature | 03/2021 | Records | EOL. Upgrade to 17 now! |
| 17 | LTS | 09/2021 | Sealed Classes | Current LTS version. Update to 17.0.3+ now! |
| 18 | Feature | 03/2022 | UTF-8 by Default | Stick to 17! It is a short term release without significant features. You might want to check if you run in any issues with “UTF-8 by Default” by setting -Dfile.encoding=UTF-8 in your current JDK. |
| 19 | Feature | 09/2022 | Preview and incubator features, only | Stick to 17! If you upgraded to 18 before, upgrade now to 20. |
| 20 | Feature | 03/2023 | Preview and incubator features, only | Stick to 17! If you upgraded to 19 before, upgrade now to 20. |
You have to decide if you want to stick with the latest LTS version, or if you go with the latest feature release and upgrade every six months. Both options are okay, but if you’re uncertain, stick with the latest LTS version.
The OpenJDK project itself is managed on openjdk.java.net where you can find specifications, source code, and mailing lists, but there are no builds that you can download. You need to choose a distribution.
Distributions
OpenJDK builds by Oracle (jdk.java.net)
Oracle provides OpenJDK builds for Linux, macOS and windows in a compressed archive format.
These builds will only be updated for a 6-month period. Updates and security patches will not be available after this short period. This also applies for LTS versions! e.g., the latest OpenJDK 11 build was 11.0.2+9 while the current OpenJDK version is 11.0.12+7.
⛔️ Recommendation: Do not use OpenJDK builds by Oracle, particularly if you plan to stick with LTS versions.
Oracle Java SE Development Kit (JDK)
Oracle provides a commercial version of the OpenJDK, which are based on the exactly same sources of the OpenJDK: The Oracle Java SE Development Kit (JDK). Oracle provides updates regular updates and security patches for these builds.
The main issue with these builds is Oracle’s licensing policy:
Until version 10, builds were published under the Oracle Binary Code License Agreement, which effectively allowed the builds to be used for commercial projects.
With version 11 to version 16 builds were published under the Oracle Technology Network License Agreement for Oracle Java SE, which require a fee-based license for usage in production. This is why many new distributions of the OpenJDK have emerged.
Version 17 is published under the Oracle No-Fee Terms and Conditions (NFTC), which allows the usage of the builds for running internal business operations. Unfortunately, the phrase “internal business operations,” is not defined and is a very vague phrase (e.g. is a public-facing website running internal business operations?).
Also, based on this volatile licensing history, it is not predictable, how future version will be licensed.
⛔️ Recommendation: Do not use Oracle Java SE Development Kit (JDK) before consulting your lawyer.
Adoptium Eclipse Temurin
Eclipse Adoptium is a top-level project under the Eclipse Foundation, which provides resources and a professional governance model for open source software. The Adoptium Working Group consists of major companies and organizations that have a strategic interest in the Java technology, including Red Hat, IBM, Microsoft, Azul, and the iJUG. The former AdoptOpenJDK project has moved to Eclipse Adoptium.
The Adoptium OpenJDK builds are called Eclipse Temurin to distinguish the project from the builds.
Eclipse Temurin builds are high-quality, vendor-neutral, and TCK-tested under a permissive license.
Adoptium states, it will continue to build binaries for LTS releases as long as the corresponding upstream source is actively maintained.
✅ Recommendation: Adoptium Eclipse Temurin OpenJDK builds are highly recommended.
AdoptOpenJDK
The AdoptOpenJDK project was the predecessor of Eclipse Adoptium and provided high-quality OpenJDK builds, both for the default HotSpot and the OpenJ9 virtual machine.
The website and older releases are kept online to access archived releases.
⛔️ Recommendation: Do not use AdoptOpenJDK anymore. Use Adoptium Eclipse Temurin instead.
Azul Zulu
Azul Systems, Inc., has specialized in professional Java technologies and commercial support for JDK. Azul has a high-industry reputation and is engaged in various working groups to evolve the Java platform.
Azul provides open source OpenJDK builds called Azul Zulu for many operating systems and architectures. Additionally, Azul provides builds for special requirements, such as stripped down JREs and builds including OpenJFX.
A downside of these builds is the dependency to a single company, that may suddenly change its license or update policies.
✅ Recommendation: Azul Zulu Builds of OpenJDK are a good choice.
Azul Zing
Azul Zing is a commercial JDK, currently marketed as Azul Platform Prime. It requires a commercial contract with Azul Systems for production use.
Zing is OpenJDK-based, and adds the patented “C4 Pauseless Garbage Collector”, the “Falcon JIT Compiler” (that optimizes for throughput at the cost of higher CPU usage and longer start-up and warm-up times), and some features to speed up compiler warm-up time (to mitigate the Falcon JIT Compiler’s slower warm-up times by profiling and storing optimizations of training runs in files).
Azul Zing has some use cases in financial trading applications, where GC pauses are a problem. Apart from that, the regular OpenJDK contains the free low-pause time GCs Shenandoah and ZGC that may be an alternative.
⚠️ Recommendation: Consider Azul Zing / Azul Platform Prime when GC pause times are a problem. Do not use it in production without a license.
BellSoft Liberica JDK
Similar to Azul, BellSoft has specialized in professional Java technologies and commercial support for JDK. Also, BellSoft has a high industry reputation and is engaged in various working groups to evolve the Java platform.
BellSoft provides open source OpenJDK builds called Liberica JDK for pretty much all operating systems and architectures.
The popular Spring Boot framework chose Liberica JDK as runtime for their buildpack.
A downside of these builds is the dependency to a single company, that may suddenly change its license or update policies.
✅ Recommendation: BellSoft Liberica JDK builds are a good choice.
IBM Semeru Runtime
IBM developed its own version of the Java Virtual Machine, called J9 and it was open-sourced as Eclipse OpenJ9. It is an alternative to the default HotSpot Java Virtual Machine, but it has never gained much popularity.
IBM now provides builds called Semeru Runtime based on the Eclipse OpenJ9 Java Virtual Machine and some OpenJDK class libraries. OpenJ9 has a low memory footprint and starts fast with shared classes, but lower throughput compared to Hotspot Virtual Machine.
⛔️ Recommendation: Use IBM Semeru Runtime only if you know that you need the OpenJ9 Virtual Machine.
Amazon Corretto
Since Oracle changed the support and license policy for its OpenJDK builds, major cloud providers decided to establish their own managed OpenJDK builds and providing long-term updates. Apparently, this is to avoid risks, especially lawsuits against Oracle.
In 2018, AWS published Corretto, yet another OpenJDK build.
AWS includes back ports of bug fixes from newer OpenJDK versions and claims that they would add patches that might not yet be integrated in the OpenJDK project. Amazon has implemented an alternative crypto provider that has been optimized for their services. It is planned to be used as the default crypto implementation in Corretto.
Amazon provides releases for major development platforms and an optimized version for its own Amazon Linux 2.
✅ Recommendation: Corretto builds are a good choice, particularly if you run Java applications directly on Amazon Linux 2 in AWS.
Microsoft Build of OpenJDK
In 2021, Microsoft published Microsoft Build of OpenJDK, yet another OpenJDK build.
Microsoft may include back ports of bug fixes from newer OpenJDK versions and claims that they would add patches that might not yet be integrated in the OpenJDK project.
Microsoft provides releases for major development platforms.
⚠️ Recommendation: Use Microsoft Build of OpenJDK, only if you run Java applications directly on Azure. There are more established options available.
Alibaba Dragonwell
Alibaba provides an OpenJDK build which includes back ports and some extra features.
⛔️ Recommendation: Do not use Alibaba Dragonwell, unless you are forced by your government.
SapMachine
SapMachine is yet another OpenJDK Build, maintained by SAP.
⚠️ Recommendation: Use SapMachine only if you are running Java applications on SAP servers. There are more established options available.
Red Hat OpenJDK
Red Hat provides OpenJDK builds for LTS versions.
⚠️ Recommendation: Use Red Hat OpenJDK only if you are running Java applications directly on Red Hat Enterprise Linux. There are more established options available.
ojdkbuild
The project is discontinued. The ojdkbuild project had the goal of providing Windows x86_64 binaries of OpenJDK that are as close in behaviour to Linux OpenJDK packages as possible, e.g. by using system libraries instead of packaged versions of zlib or OpenSSL. It used the packages included in CentOS. A use case for these builds was to develop Java software on Windows machines and deploy them to Linux servers in production.
⛔️ Recommendation: Do not use ojdkbuild, as the project is discontinued.
GraalVM
GraalVM is a fully compliant JDK, but much different from all the others builds.
GraalVM was developed by Oracle. It is based on the OpenJDK but includes a new high-performance compiler and a new polyglot virtual machine (can execute code written in different programming languages). It is also possible to create platform-specific native executable that are highly optimized and start extremely fast.
�� Please share your experiences with GraalVM in production, so that we can elaborate a validated recommendation.
Special Cases
Apple Silicon
The official support for macOS/AArch64 was implemented with JEP 391 in the OpenJDK 17 release.
macOS x64 builds run stable with Rosetta 2, but there is a significant performance drop due to emulation. People that develop on an Apple Silicon Mac (like me) should install a native macOS AArch64 (aka ARM 64) build of the JDK.
Most distributions have macOS/AArch64 builds for Java 17+, only. BellSoft Liberica and Azul Zulu also provide free macOS/AArch64 builds for Java 8 and Java 11.
Java Versions and Features
You can use this guide to get practical information on how to find and install the latest Java, understand the differences between Java distributions (Adoptium, AdoptOpenJdk, Temurin, OpenJDK, OracleJDK etc.), as well as get an overview of Java language features, including version Java versions 8-19.
Practical Information
First, let’s have a look at some common, practical questions that people have when trying to choose the right Java version for their project.
TL;DR I only want a download link and know about everything else. Where should I go?
Go to the Adoptium site, choose the very latest release version, download and install it. Then come back to this guide to maybe still learn a thing or two about Java versions.
What is the latest Java version?
As of March 2023, Java 20 is the latest released Java version. In September 2023, Java 21 will follow. The current long-term support version (LTS) of Java is Java 17, released in September 2021.
What Java version should I use?
Newer Java versions now follow every 6 months. Hence, Java 21 is scheduled for September 2023, Java 22 for March 2024 and so on. In the past, Java release cycles were much longer, up to 3-5 years. This graphic demonstrates that:
With that many new versions coming out, there’s basically these real-world(™) usage scenarios:
Legacy projects in companies are often stuck with using Java 8 (see Why are companies still stuck with Java 8?) . Hence you will be forced to use Java 8 as well.
Some legacy projects are even stuck on Java 1.5 (released 2004) or 1.6 (released 2006) — sorry, folks, I feel for you!
If you are making sure to use the very latest IDEs, frameworks and build tools and starting a greenfield project, you can, without hesitation, use Java 17 (LTS) or even the very latest Java 19.
There’s the special field of Android development, where the Java version is basically stuck at Java 7, with a specific set of Java 8 features available. Or you switch to using the Kotlin programming language.
Why are companies still stuck with Java 8?
There’s a mix of different reasons some companies are still stuck with Java 8. To name a few:
Build tools (Maven, Gradle etc.) and some libraries initially had bugs with versions Java versions > 8 and needed updates. For example, certain build tools like Maven would print out «reflective access»-warnings when building Java projects, which simply «felt not ready», even though the builds were fine.
Up until Java 8 you were pretty much using Oracle’s JDK builds and you did not have to care about licensing. Oracle changed the licensing scheme In 2019, though, which led the internet go crazy with a ton of articles saying «Java is not free anymore» — and a fair amount of confusion followed. This is however not really an issue, which you’ll learn about in the Java Distributions section of this guide.
Some companies have policies to only use LTS versions and rely on their OS vendors to provide them these builds, which takes time.
To sum up: you have a mix of practical issues (upgrading your tools, libraries, frameworks) and political issues.
Why are some Java versions, like 8 also called 1.8?
Java versions before 9 simply had a different naming scheme. So, Java 8 can also be called 1.8, Java 5 can be called 1.5 etc. When you issued the ‘java -version’ command, with these versions you got output like this:
Which simply means Java 8. With the switch to time-based releases with Java 9 the naming scheme also changed, and Java versions aren’t prefixed with 1.x anymore. Now the version number looks like this:
What is the difference between the Java versions? Should I learn a specific one?
Coming from other programming languages with major breakages between releases, like say Python 2 to 3, you might be wondering if the same applies to Java.
Java is special in this regard, as it is extremely backwards compatible. This means that your Java 5 or 8 program is guaranteed to run with a Java 8-20 virtual machine — with a few exceptions you don’t need to worry about for now.
It obviously does not work the other way around, say your program relies on Java 20 features, that are simply not available under a Java 8 JVM.
This means a couple of things:
You do not just «learn» a specific Java version, like 12.
Rather, you’ll get a good foundation in all language features up until Java 8. This serves as a good base.
And then learn, from a guide like this, what additional features came in Java 9-20 and use them whenever you can.
What are examples of these new features between Java versions?
Have a look at the Java Features 8-20 section.
But as a rule of thumb: The older, longer release-cycles (3-5 years, up until Java 8) meant a lot of new features per release.
The 6-month release cycle means a lot less features, per release, so you can catch up quickly on Java 9-20 language features.
What is the difference between a JRE and a JDK?
Up until now, we have only been talking about «Java». But what is Java exactly?
First, you need to differentiate between a JRE (Java Runtime Environment) and a JDK (Java Development Kit).
Historically, you downloaded just a JRE if you were only interested in running Java programs. A JRE includes, among other things, the Java Virtual Machine (JVM) and the «java» command line tool.
To develop new Java programs, you needed to download a JDK. A JDK includes everything the JRE has, as well as the compiler javac and a couple of other tools like javadoc (Java documentation generator) and jdb (Java Debugger).
Now why am I talking in past tense?
Up until Java 8, the Oracle website offered JREs and JDKs as separate downloads — even though the JDK also always included a JRE in a separate folder. With Java 9 that distinction was basically gone, and you are always downloading a JDK. The directory structure of JDKs also changed, with not having an explicit JRE folder anymore.
So, even though some distributions (see Java Distributions section) still offer a separate JRE download, there seems to be the trend of offering just a JDK. Hence, we are going to use Java and JDK interchangeably from now on.
How do I install Java or a JDK then?
Ignore the Java-Docker images, .msi wrappers or platform-specific packages for the moment. In the end, Java is just a .zip file, nothing more, nothing less.
Therefore, all you need to do to install Java onto your machine, is to unzip your jdk-<5-20>.zip file. You don’t even need administrator rights for that.
Your unzipped Java file will look like this:
The magic happens in the /bin directory, which under Windows looks like this:
So all you need to do is unzip that file and put the /bin directory in your PATH variable, so you can call the ‘java’ command from anywhere.
(In case you are wondering, GUI installers like the one from Oracle or Adoptium will do the unzipping and modifying the PATH variable for you, that’s about it.)
To verify you installed Java correctly, you can then simply run ‘java -version’. If the output looks like the one below, you are good to go.
Now there’s one question left: Where do you get that Java .zip file from? Which brings us to the topic of distributions.
Java Distributions
There’s a variety of sites offering Java (read: JDK) downloads and it is unclear «who offers what and with which licensing». This section will shed some light on this.
The OpenJDK project
In terms of Java source code (read: the source code for your JRE/JDK), there is only one, living at the OpenJDK project site.
This is just source code however, not a distributable build (think: your .zip file with the compiled java command for your specific operating system). In theory, you and I could produce a build from that source code, call it, say, MarcoJDK and start distributing it. But our distribution would lack certification, to be able to legally call ourselves Java SE compatible.
That’s why in practice, there’s a handful of vendors that actually create these builds, get them certified (see TCK) and then distribute them.
And while vendors cannot, say, remove a method from the String class before producing a new Java build, they can add branding (yay!) or add some other (e.g. CLI) utilities they deem useful. But other than that, the original source code is the same for all Java distributions.
OpenJDK builds (by Oracle) and OracleJDK builds
One of the vendors who builds Java from source is Oracle. This leads to two different Java distributions, which can be very confusing at first.
OpenJDK builds by Oracle(!). These builds are free and unbranded, but Oracle won’t release updates for older versions, say Java 15, as soon as Java 16 comes out.
OracleJDK, which is a branded, commercial build starting with the license change in 2019. Which means it can be used for free during development, but you need to pay Oracle if using it in production. For this, you get longer support, i.e. updates to versions and a telephone number you can call if your JVM goes crazy. In September 2021, starting with Oracle Java 17, Oracle introduced the No-Fee Terms and Conditions License, making OracleJDK free again, with a couple of limitations you can read about by spending hours on the Oracle website.
Now, historically (pre-Java 8) there were actual source differences between OpenJDK builds and OracleJDK builds, where you could say that OracleJDK was ‘better’. But as of today, both versions are essentially the same, with minor differences.
It then boils down to you wanting paid, commercial support (a telephone number) for your installed Java version.
Adoptium’s Eclipse Temurin (formerly AdoptOpenJDK)
In 2017, a group of Java User Group members, developers and vendors (Amazon, Microsoft, Pivotal, Redhat and others) started a community, called AdoptOpenJDK. As of August 2021, the AdoptOpenJDK project moved to a new home and is now called the Eclipse Adoptium project. Here is the current list of Adoptium Working Group Members.
Adoptium provides free, rock-solid OpenJDK builds, called Eclipse Temurin , with longer availibility/updates, across a variety of operating systems, architectures and versions.
Highly recommended if you are looking to install Java.
Azul Zulu, Amazon Corretto, SAPMachine
You will find a complete list of OpenJDK builds at the OpenJDK Wikipedia site. Among them are Azul Zulu, Amazon Corretto as well as SapMachine, to name a few. To oversimplify it boils down to you having different support options/maintenance guarantees.
Still, if you’re, for example, working on AWS, it makes sense to just go with their Amazon Corretto OpenJDK builds, provided they offer the Java version you want to use.
A Complete OpenJDK Distribution Overview
Rafael Winterhalter compiled a great list of all available OpenJDK builds, including their OS, architecture, licensing, support and maintenance windows.
Recommendation
To re-iterate from the beginning, in 2023 and beyond, unless you have very specific requirements, go get your jdk.zip (.tar.gz/.msi/.pkg) file from https://adoptium.net (called Eclipse Temurin ) or choose a package provided by your OS-vendor / cloud-provider.
Java Features 8-20
As mentioned at the very beginning of this guide: Essentially all (don’t be picky now) Java 8 language features also work in Java 20. The same goes for all other Java versions in between.
Which in turns means that all language features from Java 8 serve as very good Java base knowledge and everything else (Java 9-20) is pretty much additional features on top of that baseline.
Here’s a quick overview of what the specific versions have to offer:
— Java 8 —
Java 8 was a massive release and you can find a list of all features at the Oracle website. There’s two main feature sets I’d like to mention here, though:
Language Features: Lambdas etc.
Before Java 8, whenever you wanted to instantiate, for example, a new Runnable, you had to write an anonymous inner class like so:
With lambdas, the same code looks like this:
You also got method references, repeating annotations, default methods for interfaces and a few other language features.
Collections & Streams
In Java 8 you also got functional-style operations for collections, also known as the Stream API. A quick example:
Now pre-Java 8 you basically had to write for-loops to do something with that list.
With the Streams API, you can do the following:
If you want more Java 8 practice
Obviously, I can only give a quick overview of each newly added Stream, Lambda or Optional method in Java 8 in the scope of this guide.
If you want a more detailed, thorough overview — including exercises — you can have a look at my Java 8 core features course.
— Java 9 —
Java 9 also was a fairly big release, with a couple of additions:
Collections
Collections got a couple of new helper methods, to easily construct Lists, Sets and Maps.
Streams
Streams got a couple of additions, in the form of takeWhile,dropWhile,iterate methods.
Optionals
Optionals got the sorely missed ifPresentOrElse method.
Interfaces
Interfaces got private methods:
Other Language Features
And a couple of other improvements, like an improved try-with-resources statement or diamond operator extensions.
JShell
Finally, Java got a shell where you can try out simple commands and get immediate results.
HTTPClient
Java 9 brought the initial preview version of a new HttpClient. Up until then, Java’s built-in Http support was rather low-level, and you had to fall back on using third-party libraries like Apache HttpClient or OkHttp (which are great libraries, btw!).
With Java 9, Java got its own, modern client — although in preview mode, which means subject to change in later Java versions.
Project Jigsaw: Java Modules and Multi-Release Jar Files
Java 9 got the Jigsaw Module System, which somewhat resembles the good old OSGI specification. It is not in the scope of this guide to go into full detail on Jigsaw, but have a look at the previous links to learn more.
Multi-Release .jar files made it possible to have one .jar file which contains different classes for different JVM versions. So your program can behave differently/have different classes used when run on Java 8 vs. Java 10, for example.
If you want more Java 9 practice
Again, this is just a quick overview of Java 9 features and if you want more thorough explanations and exercises, have a look at the Java 9 core features course.
— Java 10 —
There have been a few changes to Java 10, like Garbage Collection etc. But the only real change you as a developer will likely see is the introduction of the «var»-keyword, also called local-variable type inference.
Local-Variable Type Inference: var-keyword
Feels Javascript-y, doesn’t it? It is still strongly typed, though, and only applies to variables inside methods (thanks, dpash, for pointing that out again).
— Java 11 —
Java 11 was also a somewhat smaller release, from a developer perspective.
Strings & Files
Strings and Files got a couple new methods (not all listed here):
Run Source Files
Starting with Java 10, you can run Java source files without having to compile them first. A step towards scripting.
Local-Variable Type Inference (var) for lambda parameters
The header says it all:
HttpClient
The HttpClient from Java 9 in its final, non-preview version.
Other stuff
Flight Recorder, No-Op Garbage Collector, Nashorn-Javascript-Engine deprecated etc.
— Java 12 —
Java 12 got a couple new features and clean-ups, but the only ones worth mentioning here are Unicode 11 support and a preview of the new switch expression, which you will see covered in the next section.
— Java 13 —
You can find a complete feature list here, but essentially you are getting Unicode 12.1 support, as well as two new or improved preview features (subject to change in the future):
Switch Expression (Preview)
Switch expressions can now return a value. And you can use a lambda-style syntax for your expressions, without the fall-through/break issues: