Shulou(Shulou.com)06/03 Report--

This article is about what are the new features of Java11. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

1.Lambda expression: (parameter)-> {body}

Lambda expressions open the door for functional programming enthusiasts to continue to use Java. The Lambda expression requires zero or more parameters that can be accessed in the body of the expression and returned with the result of the evaluation.

Comparator comparator = (a, b)-> a murb

System.out.println (comparator.compare (3,4)); / /-1

two。 Function interface: an interface with only one method

The lambda expression itself is treated as a functional interface that can be assigned to a function interface, as shown above. Java 8 also provides new functional constructs as follows:

BiFunction comparator = (a, b)-> a murb

System.out.println (comparator.apply (3,4)); / /-1

For more functional structure, see the java.util.function package, which has: Function,Supplier,Consumer,Predicate, etc. You can also use the following annotations to define function interfaces:

@ FunctionalInterface

An interface can also have one or more default implementations of a method and can still remain a functional interface. It helps to avoid unnecessary default implementations of abstract base classes.

You can use the:: operator to access static and instance methods, and you can use:: new to access constructors, and you can pass them as function parameters, such as System.out::println.

3. Stream: not just iterations

A stream is a series of objects and operations. Many default methods have been added to the interface to support the forEach, filter, map, and reduce construction of the stream. The Java library that provides collections now supports streaming. For example, BufferredReader.lines (). All collections can be easily converted to streams. Parallel flow operations are also supported, which are internally assigned to operations on multiple CPU.

1) Intermediate operation: lazy operation

When executing lazily on an intermediate operation, nothing happens until the call to terminate the operation.

Map (mapping): each element is one-to-one and converted to another form.

Filter (predicate): a filter element whose predicate is true.

Peek (), limit (), and sorted () are other intermediate operations.

2) terminate operation: result operation

ForEach (consumer): iterate through each element and consume it

Reduce (initialValue,accumulator): it starts with initialValue and iterates over each element, keeping the value updated with the final returned value.

Collect (collector): this is a lazy assessment that requires a collection using a collector, such as java.util.stream.Collectors, including toList (), join (), summarizingX (), averagingX (), groupBy (), and partitionBy ().

4. Optional: eliminate Null programming

Null-based programming is considered bad, but there are few options to avoid it in advance. Instead of testing null, we can now test isPresent () in the Optional object. Reading it (the stream also has multiple constructs and operations) returns an Optional object.

5. JVM change: PermGen has retired

PermGen has been completely deleted and replaced by MetaSpace. Metaspace is no longer a part of heap memory, but rather a part of native memory allocated to processes. JVM tuning now requires different aspects because monitoring is necessary, not only for the heap, but also for native memory.

Some combinations of GC have been deprecated. GC is automatically assigned based on the environment configuration.

There are other changes, including NIO, DateTime, Security, concise JDK configuration files, and jDeps,jjs,JavaScript Engine tools.

6.Java 9: continue the convention of the previous version

Java 9 has been around for more than a year, continuing the tradition of 8. However, its key feature module system has not been well adopted. In my opinion, it will take more time to really adopt these features in the mainstream. It challenges developers in the form of design classes. They now need to think more about application modules, not just a set of classes. In any case, this is a similar challenge for traditional developers through micro-service-based development. Java 9 continues to add functional programming features to keep Java alive and improve JVM internals.

1) Java platform module system: small is big

The most famous feature of Java 9 is the Java platform Module system (JPMS). This is an important step towards true encapsulation. Break a large module into a small and clear module made up of closely related code and data. It is similar to the OSGi package, where each package defines the dependencies it consumes and exposes what other modules depend on.

It introduces the assembly phase between compilation and runtime, and you can build custom run-time images of JDK and JRE. Now, JDK itself is made up of modules.

~ java-- list-modulesjava.activation@9.0.2java.base@9.0.2java.compiler@9.0.2java.corba@9.0.2...

These modules are called system modules. The jar without module information is loaded into the unnamed module. We can define our own application module by providing the following information in the file module-info.java:

Requires- depends on other modules

Public API/ interface for packages in the exports- export module

Opens- opens the reflection access package

Uses- is similar to requires.

For more information, see the Quick start Guide ().

2) create a module example

Here are the quick steps in IntelliJ IDE:

1. Create a module in IntelliJ: go to File > New > Module-"first.module"

two。 Create a java class (/ first.module/src) in src under the module

3. Write code

Package com.test.modules.print;public class Printer {public static void print (String input) {System.out.println (input);}}

4. Add module-info.java: / first.module/src > New > package

Module first.module {exports com.test.modules.print; / / the public apis of the export package.}

5. Similar to the previous, create the modules "main.module" and Main.java:

Module main.module {requires first.module;}

Main file code:

Package com.test.modules.main;import com.test.modules.print.Printer;public class Main {public static void main (String [] args) {Printer.print ("Hello World");}}

6. IntelliJ automatically compiles it and records dependencies and-- module-source-path

7. To run Main.java, it needs-- module-path or-m

Java-p / Workspaces/RnD/out/production/main.module:/Workspaces/RnD/out/production/first.module-m main.module/com.test.modules.main.MainHello WorldProcess finished with exit code 0

So, in this way, we can define the module.

3) other new features

Java 9 comes with many other features. Here are some important parts (also to catch up with competitors):

Responsive programming-Java 9 introduces response streaming, which supports React, just like asynchronous / wait communication between publishers and consumers. It adds a standard interface to the Flow class.

JShell- Java Shell-, like any other scripting language, Java can now be used as a scripting language.

Flow and collection enhancements: Java 9 adds some API related to "ordered" and "optional" stream operations. Add an of () operation to simplify the creation of collections, just like JavaScript.

JVM self-tuning

G1 is the default self-tuning feature in GC,GC has also been improved. CMS has been deprecated.

Access stack

The StackWalker class is added to deferred access to stack frames, which we can traverse and filter into.

Multi-release JAR file: MRJAR

A Java program may contain classes that are compatible with multiple versions. To be honest, I'm not sure how useful this feature is.

7.Java 10: closer to functional languages

1) Type inference

Java 10 brings JavaScript's var. Not only are you free to declare the types of variables, but you are also free to build collection types. The following is valid in Java 10:

Var test = "9"; test = 1.0 X var set = Set.of (5, "X", 6.5, new Object ())

The code is becoming more and more verbose, and the magic of scripting languages is increasingly being added to Java. It will certainly have a negative impact on these features of Java, but it gives developers a lot of motivation.

2) more powerful JVM

In parallel, GC fully triggers G1 to improve overall performance.

Heap allocation can be allocated on standby storage devices connected to the system. It will help to prioritize the Java process on the system. Compared with the important priority, the low priority memory can use the slow memory.

Java 10 also improves threading in native handshake threads. Previous compilation (experimental) has also been added. Generating enhanced bytecode for loops is another interesting feature of Java 10.

3) enhanced language-level features

In Java 10, we improved Optional, the immutable collection API.

Thank you for reading! This is the end of this article on "what are the new features of Java11". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.