تغییرات هر ورژن جاوا (پس از جاوا ۸)

Java 8 (2014):

Lambda Expressions: Java 8 introduced lambda expressions, which allow the representation of anonymous functions. Lambda expressions provide a concise way to express behavior as a method argument or code block.

Functional Interfaces: Functional interfaces are interfaces that contain a single abstract method. Java 8 introduced the @FunctionalInterface annotation to indicate such interfaces explicitly. Functional interfaces are crucial for working with lambda expressions and the functional programming style.

Stream API: The Stream API is a new abstraction introduced in Java 8, providing a declarative and functional approach to process collections of data. Streams allow for efficient and parallel execution of operations such as filtering, mapping, reducing, and sorting on collections.

Default Methods: Default methods allow interfaces to have method implementations. This feature was introduced to provide backward compatibility and enable the addition of new methods to existing interfaces without breaking implementing classes.

Method References: Method references provide a way to refer to methods or constructors without invoking them. They can be used to pass behavior as a method argument, similar to lambda expressions, but in a more concise manner.

Optional: The Optional class was introduced as a container object to represent an optional value. It encourages a more explicit and safer way of handling null values and helps avoid NullPointerExceptions.

Date and Time API: Java 8 introduced a new Date and Time API, also known as the “java.time” API, to address the shortcomings of the old Date and Calendar classes. The new API provides improved functionality for handling dates, times, durations, and time zones.

Default and Static Methods in Interfaces: Java 8 allowed interfaces to have static methods and default method implementations. Static methods can be directly called on the interface, while default methods provide a default implementation that can be overridden by implementing classes.

Java 9 (2017):

Module System (Project Jigsaw): Introduced a modular system for organizing and packaging Java applications.

JShell: An interactive shell (REPL) for Java, allowing developers to experiment and evaluate code snippets.

Reactive Streams: Added support for reactive programming by introducing the Flow API for handling asynchronous streams of data.

HTTP/2 Client: A new built-in HTTP client API, providing a more modern and flexible way to send HTTP requests and handle responses.

Java 10 (2018):

Local Variable Type Inference: Introduced the var keyword, allowing developers to declare local variables with implicit type inference.

Consolidated JDK: Made improvements to the JDK structure by removing some modules and merging others.

Java 11 (2018):

Local Variable Syntax for Lambda Parameters: Extended the use of the var keyword to lambda parameters.

HTTP Client: Standardized the HTTP client introduced in Java 9 and made it a supported feature.

Java 12 (2019):

Switch Expressions (Preview): Enhanced the switch statement to also work as an expression, allowing for more concise code.

Java 13 (2019):

Text Blocks: Introduced a new way to write multiline strings, making it easier to format and read strings that span multiple lines.

Java 14 (2020):

Records (Preview): Introduced a new type declaration called records, providing a concise way to declare classes that are mainly used for data storage.

Java 15 (2020):

Sealed Classes (Preview): Introduced the ability to define sealed classes and interfaces, restricting which classes can inherit or implement them.

Java 16 (2021):

Pattern Matching for instanceof: Simplified common coding patterns by introducing pattern matching for the instanceof operator.