From Java 9 to Java 17 to Java 10

In the previous article, we reviewed some of the features of Java 9, and today we will take a look at what features Java 10 brings. The reason why we need to summarize the features of Java 8 to Java 17 is because the Java community attaches unprecedented importance to Java 17. Without saying much, let's go into Java 10.

Java 10

Starting from Java 10, Java's iteration cycle has been shortened to half a year, with a version released every half a year.

local-variable type inference

Initialize one in Java 6MapWe need to make this statement:

Map<String, String> map = new HashMap<String,String>();

In fact, the parameters of generic methods can be inferred through the context, so in Java 7 it is simplified to:

Map<String, String> map = new HashMap<>();

When Java 10 further sublimates type inference, let's take an example:

        var map = Map.of("hello","world");
        String var = map.get("hello");

At first glance, I thought it was Javascript, but in fact it was Java.The compiler infers the initialization type from the type of the initializer on the right, this will significantly reduce some boilerplate code.However, please note that this feature only applies to initializing local variables and cannot be used in scenarios such as member variables, method parameters, return types, etc.

Another thing to pay attention to isvar They are not keywords in Java, which ensures backward compatibility in Java. additionally usevarThere is no runtime overhead and it does not make Java a dynamic language.varThe types of marked variables are still inferred at compile time.

var should not be abused

Although this "feels good", butvarNor should it be abused.

The following writing details are poorly readable, resulting in the variable types requiring you to DEBUG:

var data = someObject.getData();

Try not to use it in the stream:

//Poor readability
var names= apples.stream()
    .map(Apple::getName)
    .collect(Collectors.toList());

Therefore, when usingvarThe necessary readability should be ensured.

Also, among the important Java feature, polymorphismvarThe performance was not perfect. ifFruithaveAppleandOrangeTwo realizations.

var x = new Apple();

if wexreassign tonew Orange()An error will be reported because after compilationxThe type has been fixed. sovarLike generics, they play a role during the compilation process. you must promisevarThe type is certain.

So again,varCombine generic diamond symbols<>What will happen?

the following empListis of typeArrayList<Object>：

var empList = new ArrayList<>();

If we need to make sure that we put in a collectionAppleYou must explicitly declare on the right:

var apples = new ArrayList<Apple>();

immutable collections

In fact, immutable collections have been strengthened in Java 9, and immutable collections have been further strengthened in Java 10. Why has immutable sets become so important?

• Immutability is one of the cornerstones of functional programming, so strengthening immutability sets will help the development of functional programming in Java.
• Security. Since the set is immutable, there is no race condition. Natural thread safety has certain advantages in both the coding process and memory usage. This feature is used in the two programming languages, Scala and Kotlin. shine.

Some new APIs have been introduced in Java 10.

set copy

Copy a set as an immutable set:

 List<Apple> copyList = List.copyOf(apples);

Any attempt to modify such a collection will result injava.lang.UnsupportedOperationExceptionabnormal.

Stream is reduced to an immutable set

Previous inductive operations of the Stream APIcollect(Collector collector)They all just generalize flows into mutable sets, and now they all have corresponding immutable sets. An example:

List<String> names= apples.stream()
    .map(Apple::getName)
    .collect(Collectors.toUnmodifiableList());

Optional.orElseThrow()

        Optional<String> optional = Optional.ofNullable(nullableVal);
        //NoSuchElementException may occur
        String  nullable = optional.get();

Optionalif the value isnulltime stealgetwill throwNoSuchElementExceptionabnormal. SemanticallygetIt should be certain that you can get something, but in fact it is abnormal. This ambiguity is too great. So one was addedorElseThrow()Methods to enhance semantics.

Other enhanced features

Java 10's performance has also been significantly enhanced, supporting G1 parallel garbage collection. In addition, just-in-time compilation technology (JIT) has been introduced, which can speed up the running speed of java programs. In addition, Java 10 also optimizes container integration. The JVM will select the number of CPU cores and memory usage based on the container configuration. There are also some other underlying optimization features that I won't talk about here. Understanding is the key. When you reach a certain level, you will understand them yourself. At this point, some changes in Java 10 have been summarized. In fact, there are not many, and they are all easy to grasp. Pay more attention and don't walk away, next time we will summarize some of the changes and improvements in Java 11.