Hidden gems in Java 19, Half 2: The actual hidden stuff

[mtaman]:~ java -version

 java model “19.0.1” 2022-10-18

 Java(TM) SE Runtime Setting (construct 19.0.1+10-21)

 Java HotSpot(TM) 64-Bit Server VM (construct 19.0.1+10-21, blended mode, sharing)

[mtaman]:~ jshell –enable-preview

|  Welcome to JShell — Model 19.0.1

|  For an introduction sort: /assist intro

jshell>

The enhancements

This part describes some additions and enhancements in Java 19.

Assist for Unicode 14.0. Java 19 gives a small however important addition for internationalization; it gives upgrades to Unicode 14.0. The java.lang.Character class now helps Degree 14 of the Unicode Character Database (UCD), which provides 838 new characters, 5 new scripts, and 37 new emoji characters.

New system properties for System.out and System.err. In the event you run an current utility with Java 19, you might even see query marks on the console as an alternative of particular characters. It is because, as of Java 19, the working system’s default encoding is used for printing to System.out and System.err.

For instance, cp1252 encoding is the default on Home windows. If that’s not what you need and also you’d desire to see output in UTF-8, add the next JVM choices when calling the appliance:

Your platform determines what these system properties’ default settings are. When the platform doesn’t have console streams, the values default to the native.encoding property’s worth. When obligatory, the launcher’s command-line choice -D can override the properties and set them to UTF-8.

In the event you don’t need to do that every time the software program launches, you can too outline the next setting variable (it begins with an underscore) to set these parameters globally:

New strategies to create preallocated hash maps and hashsets. You may marvel why you would wish new strategies to create preallocated hash maps and hashsets. Right here’s an instance to make clear that extra: If you wish to create an ArrayList of 180 components, you possibly can write the next code:

The underlying array, the ArrayList, is allotted immediately for 180 components and doesn’t must be enlarged a number of instances as you insert the 180 components.

Equally, you may attempt to create a HashMap with 180 preallocated mappings as follows:

Intuitively, you’ll assume that this new HashMap affords house for 180 mappings. Nonetheless, it doesn’t! This occurs as a result of the HashMap has a default load issue of 0.75 when it’s initialized. This means that the HashMap will get rebuilt (additionally known as rehashed) with double the scale as quickly as it’s 75% stuffed. Thus, the brand new HashMap is initialized with a capability of 180 and might maintain solely 135 (180 × 0.75) mappings with out being rehashed.

Due to this fact, to create a HashMap for 180 mappings, calculate the capability by dividing the variety of mappings by the load issue: 180 ÷ 0.75 = 240. So, a HashMap for 180 mappings could be created as follows:

// for 180 mappings: 180 / 0.75 = 240

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

Java 19 makes it simpler to create a HashMap that has the required mappings with out fidgeting with load elements through the use of the brand new static manufacturing facility technique newHashMap(int).

Take a look at the supply code to see the way it works.

public static <Ok, V> HashMap<Ok, V> newHashMap(int numMappings) {

    return new HashMap<>(calculateHashMapCapacity(numMappings));

}

static closing float DEFAULT_LOAD_FACTOR = 0.75f;

static int calculateHashMapCapacity(int numMappings) {

    return (int) Math.ceil(numMappings / (double) DEFAULT_LOAD_FACTOR);

}

Comparable labor-saving static manufacturing facility strategies have been created in Java 19. Right here’s the entire set.

◉ HashMap.newHashMap

◉ LinkedHashMap.newLinkedHashMap

◉ WeakHashMap.newWeakHashMap

◉ HashSet.newHashSet

◉ LinkedHashSet.newLinkedHashSet

TLS signature schemes. Functions now can alter the signature schemes utilized in particular TLS or Datagram Transport Layer Safety (DTLS) connections utilizing two new Java SE strategies, setSignatureSchemes() and getSignatureSchemes(), that are discovered within the class javax.web.ssl.SSLParameters.

The underlying supplier might set the default signature schemes for every TLS or DTLS connection. Functions may alter the provider-specific default signature schemes through the use of the jdk.tls.server.SignatureSchemes and jdk.tls.shopper.SignatureSchemes system attributes. The setSignatureSchemes() technique overrides the default signature schemes for the required TLS or DTLS connections if the signature schemes parameter isn’t null.

It is suggested that when third-party distributors add help for Java 19 or later releases, in addition they add help for these strategies. The JDK SunJSSE supplier helps this method. Nonetheless, try to be conscious {that a} supplier may not have acquired an replace to help the brand new APIs, during which case the supplier may disregard the established signature schemes.

Assist for PAC-RET safety on Linux/AArch64. To defend towards Return Oriented Programming (ROP) assaults (documentation right here), OpenJDK makes use of {hardware} options from the ARM v8.3 Pointer Authentication Code (PAC) extension however solely when they’re enabled.

To make use of this performance, OpenJDK should first be compiled utilizing GCC 9.1.0+ or LLVM 10+ with the configuration flag –enable-branch-protection. Then, if the system helps it and the Java binary was compiled with department safety enabled, the runtime flag -XX:UseBranchProtection=normal will allow PAC-RET safety; in any other case, the flag is quietly ignored. A warning might be printed to the console if the system doesn’t help PAC-RET safety or if the Java binary was not constructed with department safety enabled. Instead, -XX:UseBranchProtection=pac-ret additionally allows PAC-RET safety.

Further date-time codecs. Java 19 brings new codecs to the java.time.format.DateTimeFormatter and DateTimeFormatterBuilder courses. In prior releases, solely 4 predefined kinds had been accessible: FormatStyle.FULL, FormatStyle.LONG, FormatStyle.MEDIUM, and FormatStyle.SHORT. Now you may specify a versatile type with the brand new DateTimeFormatter.ofLocalizedPattern(String requestedTemplate) technique.

For instance, the next creates a formatter that will format a date in response to a locale, for instance, “Feb 2022” within the US locale and “2022年2月” within the Japanese locale:

There’s additionally a brand new supporting perform: DateTimeFormatterBuilder.appendLocalized(String requestedTemplate).

Computerized technology of the category knowledge sharing archive. With Java 19, the JVM choice -XX:+AutoCreateSharedArchive robotically creates or updates an utility’s class knowledge sharing (CDS) archive, for instance

The desired CDS archive might be written if it doesn’t exist or if a distinct model of the JDK generated it.

Javadoc search enhancements. Java 19 can create a standalone search web page for the API documentation produced by Javadoc, and the search syntax has been improved to help a number of search phrases.

Highlighting of deprecated components, variables, and key phrases. The Java Shell instrument (jshell) now marks deprecated components and highlights deprecated variables and key phrases within the console.

Specified stack dimension not rounded up. Traditionally, the precise Java thread stack dimension may differ from the worth supplied by the -Xss command-line choice; it could be rounded as much as a a number of of the system web page dimension when that’s required by the working system. That’s been fastened in Java 19, so the stack dimension specified is what you get.

Bigger default key sizes for cryptographic algorithms. What occurs if the caller doesn’t specify a key dimension when utilizing a KeyPairGenerator or KeyGenerator object to generate a key pair or secret key? In such circumstances, JDK suppliers use provider-specific default values.

Java 19 will increase the default key sizes for varied cryptographic algorithms as follows:

◉ Elliptic Curve Cryptography (ECC): elevated from 256 to 384 bits

◉ Rivest-Shamir-Adleman (RSA), RSASSA-PSS, and Diffie-Hellman (DH): elevated from 2,048 to three,072 bits

◉ Superior Encryption Normal (AES): elevated from 128 to 256 bits, if permitted by the cryptographic coverage; in any other case, it falls again to 128

As well as, the default digest technique utilized by the jarsigner instrument has modified from SHA-256 to SHA-384. The jarsigner instrument’s default signature algorithm has additionally been modified to replicate this. Apart from more-extended key sizes whose safety energy matches SHA-512, SHA-384 is used as an alternative of SHA-256.

Notice that jarsigner will maintain utilizing SHA256withDSA because the default signature algorithm for Digital Signature Algorithm (DSA) keys to assist with interoperability with earlier Java editions.

Linux cpu.shares argument not misinterpreted. The Linux cgroups argument cpu.shares was improperly interpreted by earlier JDK editions. When the JVM was run inside a container, this might consequence within the JVM utilizing fewer CPUs than had been accessible, underutilizing CPU assets.

With Java 19, the JVM will not, by default, take cpu.shares under consideration when figuring out what number of threads to allocate to the assorted thread swimming pools.

To return to the outdated habits, use the command-line choice -XX:+UseContainerCpuShares, however remember that this feature is deprecated and could be eradicated in a subsequent JDK launch.

Bug fixes and modifications

This part describes a few of the bug fixes and modifications in Java 19.

◉ Three new closing strategies have been added: Thread.isVirtual(), Thread.threadId(), and Thread.be a part of(Period). Suppose there may be current compiled code that extends Thread, and the subclass declares a way with the identical title, parameters, and return sort as any of those strategies. In such a case, IncompatibleClassChangeError might be thrown at runtime if the subclass is loaded.

◉ The Thread class defines a number of new strategies. If considered one of your supply code recordsdata extends Thread and a way within the subclass conflicts with any of the brand new Thread strategies, the file won’t compile with out being modified.

◉ Thread.Builder is added as a nested interface. If considered one of your supply code recordsdata extends Thread and imports a category named Builder, and the code within the subclass references Builder as a easy title, the file won’t compile with out being modified.

For instance, the next code now prints zoozoobar not zoobarzoobar:

StringBuilder builder = new StringBuilder(“zoo”);

System.out.println(“” + builder + builder.append(“bar”));

Lambda deserialization for object technique references on interfaces. Deserialization of serialized technique references to Object strategies, which used an interface as the kind on which the strategy is invoked, can now be deserialized once more.

Remember the fact that the category recordsdata should be recompiled to help deserialization.

POSIX file entry attributes copied to the goal on a international file system. When two recordsdata are linked to totally different file system suppliers, comparable to if you copy a file from the default file system to a zipper file system, the Java 19 perform java.nio.file.Recordsdata.copy(Path, Path) copies Moveable Working System Interface (POSIX) file attributes from the supply file to the vacation spot file.

The POSIX file attribute view should be supported by each the supply and goal file methods. The proprietor and group proprietor of the file usually are not copied; the POSIX attributes copied are restricted to the file entry rights.

Strategies of InputStream and FilterInputStream not synchronized. The mark and reset capabilities of the java.io.InputStream and java.io.FilterInputStream courses not use the key phrase synchronized. Because the different strategies in these courses don’t synchronize, this key phrase is ineffective and has been eliminated in Java 19.

Some returned strings barely totally different. In Java 19, the specification of the Double.toString(double) and Float.toString(float) strategies is now tighter than in earlier releases, and the brand new implementation totally adheres to the specification.

The results of this modification is that some returned strings are actually shorter than when earlier Java releases are used, and inputs on the extremes of the subnormal ranges close to zero may look totally different. Nonetheless, the variety of circumstances the place there’s a distinction in output is comparatively small in comparison with the sheer variety of potential double and float inputs.

For instance, the double subnormal vary is Double.toString(1e-323), which now returns 9.9E-324, as mandated by the brand new specification. One other instance: Double.toString(2e23) now returns 2.0E23; in earlier releases, it returns 1.9999999999999998E23.

Person’s house listing set to $HOME if invalid. The consumer.house system property on Linux and macOS methods is about to the working system’s specified house listing. The worth of the setting variable $HOME is used instead of the listing title if the variable is empty or incorporates just one character.

Sometimes, $HOME has a legitimate worth and the identical listing title. Besides in methods comparable to system on Linux or when operating in a container comparable to Docker, the default to $HOME is uncommon and unlikely to occur.

Java 19 was modified to make use of the right consumer house listing.

Deprecation

This part describes the options, choices, and APIs deprecated in Java 19.

Deprecation of Locale class constructors. In Java 19, the general public constructors of the Locale class had been marked as deprecated. It’s best to use the brand new static manufacturing facility technique Locale.of() to make sure just one occasion per Locale configuration.

The next instance reveals using the manufacturing facility technique in comparison with the outdated constructor:

Locale japanese = new Locale(“ja”); // deprecated

Locale japan    = new Locale(“ja”, “JP”); // deprecated

Locale japanese1 = Locale.of(“ja”);

Locale japan1    = Locale.of(“ja”, “JP”);

System.out.println(“japanese  == Locale.JAPANESE = ” + (japanese  == Locale.JAPANESE));

System.out.println(“japan     == Locale.JAPAN    = ” + (japan     == Locale.JAPAN));

System.out.println(“japanese1 == Locale.JAPANESE = ” + (japanese1 == Locale.JAPANESE));

System.out.println(“japan1    == Locale.JAPAN    = ” + (japan1    == Locale.JAPAN));

While you run this code, you will notice that the objects equipped by way of the manufacturing facility technique are similar to the Locale constants, whereas these created with constructs logically usually are not.

A number of java.lang.ThreadGroup strategies degraded. In Java 14 and Java 16, many Thread and ThreadGroup strategies had been marked as deprecated for removing. Now, the next strategies have been decommissioned in Java 19:

◉ ThreadGroup.destroy() invocations might be ignored.

◉ ThreadGroup.isDestroyed() at all times returns false.

◉ ThreadGroup.setDaemon() units the daemon flag, however this has no impact.

◉ ThreadGroup.getDaemon() returns the worth of the unused daemon flags.

◉ ThreadGroup.droop(), resume(), and cease() throw an UnsupportedOperationException.

Eliminated objects

This part describes the outdated options, choices, and APIs eliminated in Java 19.

TLS cipher suites utilizing 3DES faraway from the default enabled record. The default record of allowed cipher suites not consists of the next TLS cipher suites that make use of the outdated Triple Knowledge Encryption (3DES) algorithm:

◉ TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA

◉ TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA

◉ TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA

◉ TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA

◉ SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA

◉ SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA

◉ SSL_RSA_WITH_3DES_EDE_CBC_SHA

Notice that cipher suites utilizing 3DES are already disabled by default within the jdk.tls.disabledAlgorithms safety property. To show them again on, you may take away 3DES_EDE_CBC from the jdk.tls.disabledAlgorithms safety parameter and re-enable the suites utilizing the setEnabledCipherSuites() perform of the SSLSocket, SSLServerSocket, or SSLEngine courses. When you are free to make use of these suites, you accomplish that at your individual danger; these had been eliminated for a purpose!

Alternately, the https.cipherSuites system property can be utilized to re-enable the suites if an utility is utilizing the HttpsURLConnection class.

Elimination of the GCParallelVerificationEnabled diagnostic flag. Disabling parallel heap verification has by no means been used aside from with its default worth as a result of there aren’t any recognized advantages to doing so. Moreover, for a really very long time, with no issues, this default worth permitted multithreaded verification. Due to this fact, the GCParallelVerificationEnabled diagnostic flag was eliminated.

SSLSocketImpl finalizer implementation eliminated. As a result of the Socket implementation now handles the underlying native useful resource releases, the finalizer implementation of SSLSocket has been deserted. With Java 19, if SSLSocket isn’t explicitly closed, TLS close_notify messages received’t be despatched.

In the event you fail to accurately shut sockets, you may see a runtime error. Functions ought to by no means depend on rubbish assortment and may at all times completely shut sockets.

Alternate ThreadLocal implementation of the Topic::present and Topic::callAs APIs eliminated. The jdk.safety.auth.topic.useTL system property and the alternate ThreadLocal implementation of the Topic::present and Topic::callAs APIs have been eliminated. The default implementation of those APIs remains to be supported.