Java 14 is **non-LTS**.

Given the new release train of 6 monthly releases and that 8 and 11 were LTS, should Java 14 not have been the **next LTS release**?

Or is purely based on the Java architects to decide which they pick for LTS?

I did search online but couldn&#39;t find an answer. 

Why is Java 14 not LTS?

**UPDATE**: Seeing as each method might be suffering from a different performance issue I decided to split this question into two:

1. https://stackoverflow.com/q/54001417/14731
2. https://stackoverflow.com/q/54008778/14731

The original discussion can be found below...

---
I was comparing my library&#39;s performance under Java 8 and 11 when I ran across some surprising numbers. Here is the benchmark code:

    import org.openjdk.jmh.annotations.Benchmark;
    import org.openjdk.jmh.annotations.BenchmarkMode;
    import org.openjdk.jmh.annotations.Mode;
    import org.openjdk.jmh.annotations.OutputTimeUnit;
    import org.openjdk.jmh.infra.Blackhole;
    
    import java.io.PrintWriter;
    import java.io.StringWriter;
    import java.util.concurrent.TimeUnit;
    
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public class MyBenchmark
    {
    	@Benchmark
    	public void emptyMethod()
    	{
    	}
    
    	@Benchmark
    	public void throwAndConsumeStacktrace(Blackhole bh)
    	{
    		try
    		{
    			throw new IllegalArgumentException(&quot;I love benchmarks&quot;);
    		}
    		catch (IllegalArgumentException e)
    		{
    			StringWriter sw = new StringWriter();
    			e.printStackTrace(new PrintWriter(sw));
    			bh.consume(sw.toString());
    		}
    	}
    }

Running with jmh 1.21, OracleJDK 1.8.0_192 returns:

    MyBenchmark.emptyMethod                avgt   25      0.363 &#177;   0.001  ns/op
    MyBenchmark.throwAndConsumeStacktrace  avgt   25  21408.072 &#177; 127.393  ns/op

OracleJDK 11.0.1 returns:

    Benchmark                              Mode  Cnt      Score      Error  Units
    MyBenchmark.emptyMethod                avgt   25      0.759 &#177;    0.034  ns/op
    MyBenchmark.throwAndConsumeStacktrace  avgt   25  47143.168 &#177; 1346.898  ns/op

OpenJDK 11.0.1 returns:

    Benchmark                              Mode  Cnt      Score     Error  Units
    MyBenchmark.emptyMethod                avgt   25      0.725 &#177;   0.001  ns/op
    MyBenchmark.throwAndConsumeStacktrace  avgt   25  47389.051 &#177; 994.345  ns/op

Granted, the absolute difference for `emptyMethod()` is tiny but the trend seems to follow for more expensive operations like `throwAndConsumeStacktrace()`. As an aside, other operations (such as throwing exceptions and never consuming their stacktrace) are only moderately slower in Java 11 so the performance drop does not apply across all operations.

I understand that microbenchmarks do not indicate the performance behavior of real-life applications. Still, I&#39;m curious where this difference is coming from. Any ideas?

Here is the full version info for the JDKs I used:

OracleJDK 8:

    java version &quot;1.8.0_192&quot;
    Java(TM) SE Runtime Environment (build 1.8.0_192-b12)
    Java HotSpot(TM) 64-Bit Server VM (build 25.192-b12, mixed mode)

OracleJDK 11.0.1:

    java version &quot;11.0.1&quot; 2018-10-16 LTS
    Java(TM) SE Runtime Environment 18.9 (build 11.0.1+13-LTS)
    Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.1+13-LTS, mixed mode)

OpenJDK 11.0.1:

    openjdk version &quot;11.0.1&quot; 2018-10-16
    OpenJDK Runtime Environment 18.9 (build 11.0.1+13)
    OpenJDK 64-Bit Server VM 18.9 (build 11.0.1+13, mixed mode)

Java 11 -- performance regressions against Java 8?

I am working on a small library and for obvious reasons I would like to write code using all the Java 11 features (except modules I guess for now), but I would like the library to be compatible with Java 8 and above.

When I try this:

    javac -source 11 -target 1.8 App.java

I get the following message:

    warning: source release 11 requires target release 11

...and when I look at the byte code I see that the version of the class is `0x37` (Java 11):

    $ xxd App.class
    00000000: cafe babe 0000 0037 ...
And Java 8 cannot load it:

    Exception in thread &quot;main&quot; java.lang.UnsupportedClassVersionError: App has been
        compiled by a more recent version of the Java Runtime (class file version 55.0),
        this version of the Java Runtime only recognizes class file versions up to 52.0
    	at java.lang.ClassLoader.defineClass1(Native Method)
    	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
    	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    	at java.net.URLClassLoader.defineClass(URLClassLoader.java:468)
    	at java.net.URLClassLoader.access$100(URLClassLoader.java:74)
    	at java.net.URLClassLoader$1.run(URLClassLoader.java:369)
    	at java.net.URLClassLoader$1.run(URLClassLoader.java:363)
    	at java.security.AccessController.doPrivileged(Native Method)
    	at java.net.URLClassLoader.findClass(URLClassLoader.java:362)
    	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
    	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    	at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

How do people provide such compatibility? I am open to all build tools.

For me it seems easy just to transform high-level language (Java) into low-level (bytecode). It appears to me that when the high-level language changes, the low-level should stay the same. That is why I thought it was possible.

**UPDATE**

Guys, I don&#39;t think that this answer duplicates [Move to OpenJDK-11 but compile in Java 8](https://stackoverflow.com/q/54147275/3686755), because there the OP asks how to keep producing the code with `Java 8` features, but target Java 11 (which is just a famous backward compatibility). My question is the other way around: I want to produce the code in Java 11, but target Java 8. I came across that question when I was researching the topic before posing the question. I didn&#39;t find it applicable to my situation.

The other question [Can Java 8 code be compiled to run on Java 7 JVM](https://stackoverflow.com/q/16143684/3686755) does look similar to my question, but it was asked in 2013 and the bytecode obviously changed between Java 7 and Java 8.

I didn&#39;t think the bytecode changed that much since Java 8 that is why I asked this question.

How to write code in Java 11, but target Java 8 and above?

JDK-11 will remove a lot of older parts of the JDK ([JEP-320][1]).
For some of them (e.g. JAXB) functionality will be provided as regular library. You simply add another dependency and everything works fine again.

But not so for CORBA, because

&gt; There is no significant interest in developing modern applications with CORBA in Java

I am however in the painful situation of needing to maintain older applications that still require CORBA while still wanting to update to JDK-11.

Is there a replacement-library out there or another good way of migrating to JDK-11 without removing the CORBA functionality of these applications?


  [1]: http://openjdk.java.net/jeps/320 &quot;JEP-320&quot;

Is there a replacement library for CORBA in JDK 11

When compiling the code below with the Java compiler from OpenJDK 8, the call to `foo()` is done via an `invokespecial`, but when OpenJDK 11 is used, an `invokevirtual` is emitted.

```java
public class Invoke {
  public void call() {
    foo();
  }

  private void foo() {}
}
```

Output of `javap -v -p` when `javac` 1.8.0_282 is used:

```
  public void call();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #2      // Method foo:()V
         4: return
```

Output of `javap -v -p` when `javac` 11.0.10 is used:

```
  public void call();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokevirtual #2      // Method foo:()V
         4: return

```

I don&#39;t get why `invokevirtual` is used here since there cannot be an override of `foo()`.

After digging a bit it seems that the purpose of `invokevirtual` on private methods is to allow nested classes to call private methods from the outer class. So I tried the code below:

```java
public class Test{
  public static void main(String[] args) {
    // Build a Derived such that Derived.getValue()
    // somewhat &quot;exists&quot;.
    System.out.println(new Derived().foo());
  }

  public static class Base {

    public int foo() {
      return getValue() + new Nested().getValueInNested();
    }

    private int getValue() {
      return 24;
    }

    private class Nested {

      public int getValueInNested() {
        // This is getValue() from Base, but would
        // invokevirtual call the version from Derived?
        return getValue();
      }
    }
  }

  public static class Derived extends Base {

    // Let&#39;s redefine getValue() to see if it is picked by the
    // invokevirtual from getValueInNested().
    private int getValue() {
      return 100;
    }
  }
}
```

Compiling this code with 11, we can see in the output of `javap` that `invokevirtual` is used both in `foo()` and in `getValueInNested()`:

```
  public int foo();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
         0: aload_0

         // ** HERE **
         1: invokevirtual #2  // Method getValue:()I
         4: new           #3  // class Test$Base$Nested
         7: dup
         8: aload_0
         9: invokespecial #4  // Method Test$Base$Nested.&quot;&lt;init&gt;&quot;:(LTest$Base;)V
        12: invokevirtual #5  // Method Test$Base$Nested.getValueInNested:()I
        15: iadd
        16: ireturn
```

```
  public int getValueInNested();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: getfield      #1  // Field this$0:LTest$Base;

         // ** HERE **
         4: invokevirtual #3  // Method Test$Base.getValue:()I
         7: ireturn
```

All of this is a bit confusing and raises some questions:

* Why `invokevirtual` is used to call private methods? Is there a use case where replacing it by an `invokespecial` would not be equivalent?
* How does the call to `getValue()` in `Nested.getValueInNested()` not pick the method from `Derived` since it is called via `invokevirtual`?

Why does the Java compiler 11 use invokevirtual to call private methods?

I&#39;m trying to deserialize XML data into a Java content tree using [JAXB][1], validating the XML data as it is unmarshalled:

&lt;!-- language: lang-java --&gt;

    try {
      JAXBContext context = JAXBContext.newInstance(&quot;com.acme.foo&quot;);
      Unmarshaller unmarshaller = context.createUnmarshaller();
      unmarshaller.setSchema(schema);
      FooObject fooObj = (FooObject) unmarshaller.unmarshal(new File(&quot;foo.xml&quot;));
    } catch (UnmarshalException ex) {
      ex.printStackTrace();
    } catch (JAXBException ex) {
      ex.printStackTrace();
    }

When I build the project with **Java 8** it&#39;s fine, but building it with **Java 11** fails with a compilation error:

    package javax.xml.bind does not exist

How do I fix the issue?


  [1]: https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/package-summary.html

Java 11 package javax.xml.bind does not exist

I have some code that uses JAXB API classes which have been provided as a part of the JDK in Java 6/7/8.  When I run the same code with Java 9, at runtime I get errors indicating that JAXB classes can not be found.

The JAXB classes have been provided as a part of the JDK since Java 6, so why can Java 9 no longer find these classes?

How to resolve java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

So Java 11 [is out][1]. Does anybody know how to install it (OpenJDK from Oracle) from the command line?

I would like to see something like it was before for Oracle Java 10:

    sudo add-apt-repository ppa:linuxuprising/java
    sudo apt-get update
    sudo apt-get install oracle-java10-installer

P. S. In the [similar][2] question proposed instruction:

    sudo apt-get install openjdk-11-jdk

doesn&#39;t work.


  [1]: https://mail.openjdk.java.net/pipermail/announce/2018-September/000257.html
  [2]: https://stackoverflow.com/questions/49507160/how-to-install-jdk-10-under-ubuntu

How to install JDK 11 under Ubuntu?

Java 11 is announced to be the most recent LTS version. So, we&#39;re trying to start new services based on this Java version.

However, the base Docker image for Java 11 is much larger than the equivalent  for Java 8:

  - [`openjdk:8-jre-alpine`][1]: 84 MB
  
  - [`openjdk:11-jre-slim`][2]: **283** MB

(I&#39;m considering only the [***official OpenJDK***][3] and ***the most lightweight*** images for each Java version.)

Deeper digging uncovered the following &quot;things&quot;:

  - the [`openjdk:11-jre-slim`][2] image uses the base image `debian:sid-slim`. This brings 2 issues: 

    - this is 60 MB larger than `alpine:3.8`
   
    - the [Debian `sid`][4] versions are unstable

  - the `openjdk-11-jre-headless` package installed in the image is **3 times larger** than `openjdk8-jre` (inside running Docker container):

    - `openjdk:8-jre-alpine`: 
  
      &gt;     / # du -hs /usr/lib/jvm/java-1.8-openjdk/jre/lib/
      &gt;     57.5M	/usr/lib/jvm/java-1.8-openjdk/jre/lib/

    - `openjdk:11-jre-slim`:

      &gt;     # du -sh /usr/lib/jvm/java-11-openjdk-amd64/lib/
      &gt;     179M	/usr/lib/jvm/java-11-openjdk-amd64/lib/

      Going deeper I discovered the &quot;root&quot; of this heaviness - it&#39;s the `modules` file of the JDK:

      &gt;     # ls -lhG /usr/lib/jvm/java-11-openjdk-amd64/lib/modules
      &gt;     135M    /usr/lib/jvm/java-11-openjdk-amd64/lib/modules

So, now the questions which came:

  - Why is `alpine` not used any more as a base image for Java 11 slim images?

  - Why is the unstable _sid_ version used for LTS Java images?

  - Why is the slim/headless/JRE package for OpenJDK 11 so large compared to the similar OpenJDK 8 package? 
    
    - What is this _modules_ file which brings 135 MB in OpenJDK 11?

**UPD**: as a solutions for these challenges one could use this answer: https://stackoverflow.com/questions/53669151/java-11-application-as-docker-image/53669152#53669152


  [1]: https://github.com/docker-library/openjdk/blob/master/8/jre/alpine/Dockerfile
  [2]: https://github.com/docker-library/openjdk/blob/master/11/jre/slim/Dockerfile
  [3]: https://hub.docker.com/_/openjdk/
  [4]: https://www.debian.org/releases/sid/

Why is the Java 11 base Docker image so large? (openjdk:11-jre-slim)

I have a trivial Maven project:

    src
    └── main
        └── java
            └── module-info.java
    pom.xml

pom.xml:

    &lt;groupId&gt;org.example&lt;/groupId&gt;
	&lt;artifactId&gt;example&lt;/artifactId&gt;
	&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;
	&lt;packaging&gt;jar&lt;/packaging&gt;
	&lt;name&gt;example&lt;/name&gt;

	&lt;build&gt;
		&lt;plugins&gt;
			&lt;plugin&gt;
				&lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;
				&lt;artifactId&gt;maven-compiler-plugin&lt;/artifactId&gt;
				&lt;version&gt;3.7.0&lt;/version&gt;
				&lt;configuration&gt;
					&lt;release&gt;10&lt;/release&gt;
				&lt;/configuration&gt;
			&lt;/plugin&gt;
		&lt;/plugins&gt;
	&lt;/build&gt;

When I build the project via `mvn -X install -DskipTests=true`, it fails:

    org.apache.maven.lifecycle.LifecycleExecutionException: Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile (default-testCompile) on project example: Execution default-testCompile of goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile failed.
            at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:213)
            at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:154)
            at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:146)
            at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:117)
            at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:81)
            at org.apache.maven.lifecycle.internal.builder.singlethreaded.SingleThreadedBuilder.build(SingleThreadedBuilder.java:51)
            at org.apache.maven.lifecycle.internal.LifecycleStarter.execute(LifecycleStarter.java:128)
            at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:309)
            at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:194)
            at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:107)
            at org.apache.maven.cli.MavenCli.execute(MavenCli.java:993)
            at org.apache.maven.cli.MavenCli.doMain(MavenCli.java:345)
            at org.apache.maven.cli.MavenCli.main(MavenCli.java:191)
            at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
            at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
            at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
            at java.base/java.lang.reflect.Method.invoke(Method.java:564)
            at org.codehaus.plexus.classworlds.launcher.Launcher.launchEnhanced(Launcher.java:289)
            at org.codehaus.plexus.classworlds.launcher.Launcher.launch(Launcher.java:229)
            at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode(Launcher.java:415)
            at org.codehaus.plexus.classworlds.launcher.Launcher.main(Launcher.java:356)
    Caused by: org.apache.maven.plugin.PluginExecutionException: Execution default-testCompile of goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile failed.
            at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:145)
            at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:208)
            ... 20 more
    Caused by: java.lang.IllegalArgumentException
            at org.objectweb.asm.ClassReader.&lt;init&gt;(Unknown Source)
            at org.objectweb.asm.ClassReader.&lt;init&gt;(Unknown Source)
            at org.objectweb.asm.ClassReader.&lt;init&gt;(Unknown Source)
            at org.codehaus.plexus.languages.java.jpms.AsmModuleInfoParser.parse(AsmModuleInfoParser.java:80)
            at org.codehaus.plexus.languages.java.jpms.AsmModuleInfoParser.getModuleDescriptor(AsmModuleInfoParser.java:54)
            at org.codehaus.plexus.languages.java.jpms.LocationManager.resolvePaths(LocationManager.java:83)
            at org.apache.maven.plugin.compiler.TestCompilerMojo.preparePaths(TestCompilerMojo.java:281)
            at org.apache.maven.plugin.compiler.AbstractCompilerMojo.execute(AbstractCompilerMojo.java:762)
            at org.apache.maven.plugin.compiler.TestCompilerMojo.execute(TestCompilerMojo.java:176)
            at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:134)
            ... 21 more


Is there a way to fix this?

Unable to compile simple Java 10 / Java 11 project with Maven

Among other changes, JDK 11 introduces 6 new methods for java.lang.String class:

 - `repeat(int)` - Repeats the String as many times as provided by the `int` parameter
 - `lines()` - Uses a Spliterator to lazily provide lines from the source string
 - `isBlank()` - Indicates if the String is empty or contains only white space characters
 - `stripLeading()` - Removes the white space from the beginning
 - `stripTrailing()` - Removes the white space from the end
 - **`strip()`** - Removes the white space from both, beginning and the end of string	

In particular, `strip()` looks very similar to `trim()`. As per [this article][1] `strip*()` methods are designed to:

&gt; The String.strip(), String.stripLeading(), and String.stripTrailing()
&gt; methods trim white space [as determined by Character.isWhiteSpace()]
&gt; off either the front, back, or both front and back of the targeted
&gt; String.

`String.trim()` JavaDoc states:

    /**
      * Returns a string whose value is this string, with any leading and trailing
      * whitespace removed.
      * ...
      */

Which is almost identical to the quote above.

What exactly the difference between `String.trim()` and `String.strip()` since Java 11?


  [1]: https://dzone.com/articles/applying-new-jdk-11-string-methods

Difference between String trim() and strip() methods in Java 11

I am trying to build an application which was built using java 8, now it&#39;s upgraded to java 11. I installed [Java 11][1] using [an oracle article][2] in my **windows machine** and I use **IntelliJ IDEA 2017** as my IDE.

I changed my system environment variables and set the 

    JAVA_HOME to C:\Program Files\Java\jdk-11.0.1
And added that to the `Path` variable.

    C:\&gt;java -version
    java version &quot;11.0.1&quot; 2018-10-16 LTS
    Java(TM) SE Runtime Environment 18.9 (build 11.0.1+13-LTS)
    Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.1+13-LTS, mixed mode) 

When I build my application in IntelliJ, this is what I get:

    Information:java: Errors occurred while compiling module &#39;test-domain_main&#39;
    Information: javac 1.8.0_171 was used to compile java sources
    Information:1/10/2019 4:21 PM - Compilation completed with 1 error and 0 warnings in 1s 199ms
    Error:java: invalid target release: 11

This is what I&#39;ve tried so far:

 1. I changed `.idea/compiler.xml` target values from 8 to 11 but that didn&#39;t help. Also, verified the `Target bytecode version` in `settings &gt; Build, Execution, Deployment &gt; Compiler &gt; Java Compiler` and all my modules are set to 11. 

 2. Went to `file &gt; Project Structure &gt; SDKs *(currently I have 1.7 and 1.7 listed)* &gt; Add new SDK &gt; JDK &gt;`
After that, I selected `C:\Program Files\Java\jdk-11.0.1` But it errors out with &quot;The selected directory is not a valid home for JDK&quot;

I am not sure if I installed the wrong JDK 11, because in my `C:\Program Files\Java\`, I see separate JDK and JRE folders for `1.7` and `1.8` but only JDK folder for `11.0.1`

Or is it something else I need to change? 

  [1]: https://www.oracle.com/technetwork/java/javase/downloads/index.html
  [2]: https://docs.oracle.com/en/java/javase/11/install/installation-jdk-microsoft-windows-platforms.html#GUID-A7E27B90-A28D-4237-9383-A58B416071CA

Error: Java: invalid target release: 11 - IntelliJ IDEA

Recently I switched to the Java 11 and start to debug my app and saw this message:

&gt; OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot
&gt; loader classes because bootstrap classpath has been appended

Found only [this commit][1] and [ticket][2], but it doesn&#39;t tell me much. 

Do I need to worry about it?


  [1]: http://hg.openjdk.java.net/jdk/jdk/rev/18fba780c1d1
  [2]: https://bugs.openjdk.java.net/browse/JDK-8203031

How to avoid &quot;Sharing is only supported for boot loader classes because bootstrap classpath has been appended&quot; warning during debug with Java 11?

We&#39;re currently migrating from Java 8 to Java 11. However, upgrading our services was less painful, than we anticipated. We basically only had to change the version number in our `build.gradle` file and the services were happily up and running. We upgraded libraries as well as (micro) services that use those libs. No problems until now.

Is there any *need* to actually switch to modules? This would generate needless costs IMHO. Any suggestion or further reading material is appreciated.

To clearify, are there any consequences if Java 9+ code is used without introducing modules? Can it e.g. become incompatible with other code?

Is there any need to switch to modules when migrating to Java 9 or later?

I&#39;m having trouble getting IntellJ to recognize JavaFX packages. With a new JavaFX project, with OpenJDK 11, when trying to build the project, IntelliJ can&#39;t recognize the JavaFX packages.

I&#39;ve imported `openjfx:javafx-base-11` from the Maven repo.

I&#39;ve looked at other questions and the solutions seem to range from checking that the bytecode is at the right level (mine is), and that the project language is correct (mine is).

Anyone have any ideas?

[![pic 1][1]][1]

[![pic 2][2]][2]

[![pic 3][3]][3]

**Edit:**

Error:

[![enter image description here][4]][4]


  [1]: https://i.stack.imgur.com/C0VJq.png
  [2]: https://i.stack.imgur.com/3XJNw.png
  [3]: https://i.stack.imgur.com/j2B8G.png
  [4]: https://i.stack.imgur.com/C2PE5.png

IntelliJ can&#39;t recognize JavaFX 11 with OpenJDK 11

Inspired by question [Why is the Java 11 base Docker image so large? (openjdk:11-jre-slim)][1] I found that this topic in Java world is still not settled.

As for `07 Dec 2018` there are common issues/pitfalls (discussed in the ticket above):

  - JRE is not distributed as a separate &quot;package&quot;. Modules from JDK should be used instead

  - [Oracle OpenJDK 11][2] doesn&#39;t support [Linux Alpine][3], so _lightweight_ images can&#39;t be easily created

    - In the same time current stable Debian versions still doesn&#39;t have [Java 11 packages][4] ([Ubuntu has Java 10 installed][5] under openjdk-11 packages), that&#39;s why unstable sid versions are used for base docker images

  - currently available Oracle openjdk-11 images build unstripped `libjvm.so` module, which has hundreds megabyte and must be stripped separately:
  
    - [jlink runtime image size (specifically libjvm.so) created from openjdk is huge. Expected it to be much smaller.][6]
    - Solution: https://github.com/docker-library/openjdk/issues/217#issuecomment-436079779

As a result of these issues even _slim_ Oracle Java 11 base images are quite heavy and considered to be unstable: https://hub.docker.com/_/openjdk/

So the question is: 

**what are _optimized_ or _recommended_ ways to build and deliver Java 11 applications as docker images**?


  [1]: https://stackoverflow.com/questions/53375613/
  [2]: https://jdk.java.net/11/
  [3]: https://openjdk.java.net/projects/portola/
  [4]: https://packages.debian.org/stable/java/
  [5]: https://packages.ubuntu.com/bionic/java/
  [6]: https://github.com/docker-library/openjdk/issues/217

Java 11 application as lightweight docker image

In the past, Oracle used to publish an executable installers for Windows that would:

* Unpack files
* Add registry keys indicating the installed version and path
* Add the JRE to the system PATH
* Register an uninstaller with Windows.

As of Java 11, the Oracle&#39;s free version of Java ([Oracle OpenJDK](http://jdk.java.net/11)) doesn&#39;t seem to include an installer. It is just a zip file containing the binaries.

How are we supposed to install OpenJDK 11 on Windows seeing as the aforementioned integrations are no longer there? Aren&#39;t they necessary?

How to install OpenJDK 11 on Windows?

Java 11 does not come with a JRE for download, unlike past Java versions. I got an error &quot;no java run-time environment&quot; when running some Java-based software. To fix the problem, I had to install Java 8 JRE. 

How can I get my PC to run Java 11 JRE given that there is no more JRE 11 to download?

I am using Windows 10.


How can I get Java 11 run-time environment working since there is no more JRE 11 for download?

I&#39;m using Eclipse(4.9.0) on my MacBook (High Sierra, Java 11) and this error is showing sometimes, if I&#39;m on another app, the errors create a &quot;stack&quot; as you see in the screenshot, it is annoying to come back to Eclipse and to close this error every time.
Can somebody help me solve this?

[![The error showing up after a while using another app][1]][1]


  [1]: https://i.stack.imgur.com/e8EO6.png

Eclipse internal error &quot;Polling news feeds&quot;

We are planning to migrate our Java 8 project to use Java 11. But I noticed that Java 11 doesn&#39;t have a JRE folder.

In Java 9 and Java 10, folder structures are changed i.e. `java\jdk1.x` or `java\jre1.x`, where `x` is Java 9 or 10.

But in Java 11, I am getting only one folder, i.e. `java\jdk-11`. How will my client use my application without *jre*?

What I understood is that Java 11 is enforcing to modularize our application, and using jlink is needed to create our own jre to run the application in client.

Is my understanding correct?




How to use JDK without JRE in Java 11

I tried to run my project on the latest Java 11. Everything works, except the specific file logger. Logging works fine on previous Java versions - 10, 9, 8, but not on Java 11.

During server run I see only 1 warning:

&gt; WARNING: sun.reflect.Reflection.getCallerClass is not supported. This
&gt; will impact performance.

Here is my configuration:

    &lt;Configuration&gt;
    
        &lt;Appenders&gt;
    
            &lt;RollingFile name=&quot;postgresDBLog&quot; fileName=&quot;${sys:logs.folder}/postgres.log&quot;
                  filePattern=&quot;${sys:logs.folder}/archive/postgres.log.%d{yyyy-MM-dd}&quot;&gt;
                &lt;PatternLayout&gt;
                    &lt;pattern&gt;%d{HH:mm:ss.SSS} - %msg%n&lt;/pattern&gt;
                &lt;/PatternLayout&gt;
                &lt;Policies&gt;
                    &lt;TimeBasedTriggeringPolicy/&gt;
                &lt;/Policies&gt;
            &lt;/RollingFile&gt;
    
            &lt;RollingFile name=&quot;workersLog&quot; fileName=&quot;${sys:logs.folder}/worker.log&quot;
                         filePattern=&quot;${sys:logs.folder}/archive/worker.log.%d{yyyy-MM-dd}&quot;&gt;
                &lt;PatternLayout&gt;
                    &lt;pattern&gt;%d{HH:mm:ss.SSS} - %msg%n&lt;/pattern&gt;
                &lt;/PatternLayout&gt;
                &lt;Policies&gt;
                    &lt;TimeBasedTriggeringPolicy/&gt;
                &lt;/Policies&gt;
            &lt;/RollingFile&gt;
    
            &lt;RollingFile name=&quot;statsLog&quot; fileName=&quot;${sys:logs.folder}/stats.log&quot;
                         filePattern=&quot;${sys:logs.folder}/archive/stats.log.%d{yyyy-MM-dd}&quot;&gt;
                &lt;PatternLayout&gt;
                    &lt;pattern&gt;%msg%n&lt;/pattern&gt;
                &lt;/PatternLayout&gt;
                &lt;Policies&gt;
                    &lt;TimeBasedTriggeringPolicy/&gt;
                &lt;/Policies&gt;
            &lt;/RollingFile&gt;
    
            &lt;RollingFile name=&quot;userLog&quot; fileName=&quot;${sys:logs.folder}/blynk.log&quot;
                         filePattern=&quot;${sys:logs.folder}/archive/blynk.log.%d{yyyy-MM-dd}&quot;&gt;
                &lt;PatternLayout&gt;
                    &lt;pattern&gt;%d{HH:mm:ss.SSS} %-5level- %msg%n&lt;/pattern&gt;
                &lt;/PatternLayout&gt;
                &lt;Policies&gt;
                    &lt;TimeBasedTriggeringPolicy/&gt;
                &lt;/Policies&gt;
            &lt;/RollingFile&gt;
    
        &lt;/Appenders&gt;
    
        &lt;Loggers&gt;
    
            &lt;Logger name=&quot;cc.blynk.server.workers&quot; level=&quot;debug&quot; additivity=&quot;false&quot;&gt;
                &lt;appender-ref ref=&quot;workersLog&quot;/&gt;
            &lt;/Logger&gt;
            &lt;Logger name=&quot;cc.blynk.server.workers.StatsWorker&quot; level=&quot;debug&quot; additivity=&quot;false&quot;&gt;
                &lt;appender-ref ref=&quot;statsLog&quot;/&gt;
            &lt;/Logger&gt;
            &lt;Logger name=&quot;cc.blynk.server.db&quot; level=&quot;debug&quot; additivity=&quot;false&quot;&gt;
                &lt;appender-ref ref=&quot;postgresDBLog&quot;/&gt;
            &lt;/Logger&gt;
            &lt;Logger name=&quot;com.zaxxer.hikari&quot; level=&quot;OFF&quot; additivity=&quot;false&quot;&gt;
            &lt;/Logger&gt;
    
            &lt;Logger name=&quot;org.asynchttpclient.netty.channel&quot; level=&quot;OFF&quot; additivity=&quot;false&quot; /&gt;
    
            &lt;!-- turn off netty errors in debug mode for native library loading
             https://github.com/blynkkk/blynk-server/issues/751 --&gt;
            &lt;Logger name=&quot;io.netty&quot; level=&quot;INFO&quot; additivity=&quot;false&quot; /&gt;
    
            &lt;Root&gt;
                &lt;AppenderRef ref=&quot;userLog&quot;/&gt;
            &lt;/Root&gt;
    
        &lt;/Loggers&gt;
    &lt;/Configuration&gt;

All loggers, except `userLog` works fine. However, `userLog` is empty.

    log4j2 version 2.11.1

    Ubuntu 16.04.5 LTS

    java version &quot;11.0.1&quot; 2018-10-16 LTS
    Java(TM) SE Runtime Environment 18.9 (build 11.0.1+13-LTS)
    Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.1+13-LTS, mixed mode)

**Update:**

Adding `level=&quot;info&quot;` to the root level fixes the issue.

        &lt;Root level=&quot;info&quot;&gt;
            &lt;AppenderRef ref=&quot;userLog&quot;/&gt;
        &lt;/Root&gt;

However, in my project I was using a code that was setting a log level based on properties file. Here is a code:

    private static void changeLogLevel(String level) {
        Level newLevel = Level.valueOf(level);
        LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
        Configuration conf = ctx.getConfiguration();
        conf.getLoggerConfig(LogManager.ROOT_LOGGER_NAME).setLevel(newLevel);
        ctx.updateLoggers(conf);
    }

Seems like this part is no longer work with Java 11.



Is log4j2 compatible with Java 11?

# UPDATE: 

&lt;sup&gt;*(to be **more clear**)*&lt;/sup&gt;

You can find [JRE 8][2], [JRE 9][3] and [JRE 10][4] on Oracle&#39;s official website (click on each). *But where is **JRE 11**?!* 

Also, JDK 11 doesn&#39;t include a JRE. I was expecting JRE to be installed with JDK.

***Do final users of our apps need to install JDK?***

***

# ORIGINAL version of the question:

I downloaded and installed Oracle JDK 11 from its [official site][5]. I installed both  `..._linux-x64_bin.rpm` and `..._windows-x64_bin.exe` (first on a Linux machine and second on a Windows machine). But I saw an unexpected thing! Where is JRE?

This is a snapshot of installation path on CentOS 7. As you can see there is no `jre` folder:

    # ls /usr/java/jdk-11.0.1/
    bin  conf  include  jmods  legal  lib  README.html  release
    
Same snapshot about Oracle JDK 8 (See `jre` folder specially):

    # ls /usr/java/jdk1.8.0_191-amd64/
    bin             lib          src.zip
    COPYRIGHT       LICENSE      THIRDPARTYLICENSEREADME-JAVAFX.txt
    include         man          THIRDPARTYLICENSEREADME.txt
    javafx-src.zip  README.html
    jre             release

***

Same snapshots on Windows machine:

    &gt; dir /b &quot;C:\Program Files\Java\jdk-11.0.1&quot; 
    bin                                           
    conf                                          
    COPYRIGHT                                     
    include                                       
    jmods                                         
    legal                                         
    lib                                           
    README.html                                   
    release                                                                                     
               
    &gt; dir /b &quot;C:\Program Files\Java\jdk1.8.0_181&quot;  
    bin                                           
    COPYRIGHT                                     
    include                                       
    javafx-src.zip                                
    jre                                           
    lib                                           
    LICENSE                                       
    README.html                                   
    release                                       
    src.zip                                       
    THIRDPARTYLICENSEREADME-JAVAFX.txt            
    THIRDPARTYLICENSEREADME.txt 

***

On Windows machine, there are also two another differences between JDK 8 and JDK 11.

 1. A standalone `JRE` alongside `JDK` as you can see:

        &gt; dir /b &quot;C:\Program Files\Java&quot;            
        jdk-11.0.1   
        jdk1.8.0_181 
        jre1.8.0_181 

 2. In path `C:\Program Files (x86)\Common Files\Oracle\Java`:

        &gt; dir &quot;C:\Program Files (x86)\Common Files\Oracle\Java&quot;                                                                   
        ...                                                                                                                   
        ...                14 java.settings.cfg                                                                  
        ...    &lt;JUNCTION&gt;     javapath [C:\Program Files (x86)\Common Files\Oracle\Java\javapath_target_3015921] 
        ...    &lt;DIR&gt;          javapath_target_3015921 
        ...

    As you see `javapath` (that is in `PATH` environment variable) points to `javapath_target_3015921`. This folder contains 3 executables of JDK 8 (that aren&#39;t *link*s!):

        &gt; dir /b &quot;C:\Program Files (x86)\Common Files\Oracle\Java\javapath&quot; 
        java.exe                         
        javaw.exe                        
        javaws.exe 

***

Finally, I searched the web to find a standalone JRE and found out it doesn&#39;t exist!

***Do final users of our programs need to install JDK?***


  [1]: https://stackoverflow.com/questions/46388117/where-is-jre-folder-in-java-9
  [2]: https://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html
  [3]: https://www.oracle.com/technetwork/java/javase/downloads/java-archive-javase9-3934878.html
  [4]: https://www.oracle.com/technetwork/java/javase/downloads/java-archive-javase10-4425482.html
  [5]: https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html

Where is JRE 11?

the following code works perfectly fine in a Java 1.8 VM but produces a `LambdaConversionException` when executed in a Java 11 VM. Wheres the difference and why does it behave like this?

---
Code:
--

&lt;!-- language: lang-java --&gt;

    public void addSomeListener(Component comp){
        if(comp instanceof HasValue) {
            ((HasValue&lt;?,?&gt;) comp).addValueChangeListener(evt -&gt; {
                //do sth with evt
            });
        }
    }

[HasValue Javadoc][1]

Exception (V11 only):
--

&lt;!-- language: lang-none --&gt;

    Caused by: java.lang.invoke.LambdaConversionException: Type mismatch
    for instantiated parameter 0: class java.lang.Object is not a subtype
    of interface com.vaadin.flow.component.HasValue$ValueChangeEvent
    	at java.base/java.lang.invoke.AbstractValidatingLambdaMetafactory.checkDescriptor(AbstractValidatingLambdaMetafactory.java:308)
     	at java.base/java.lang.invoke.AbstractValidatingLambdaMetafactory.validateMetafactoryArgs(AbstractValidatingLambdaMetafactory.java:294)
     	at java.base/java.lang.invoke.LambdaMetafactory.altMetafactory(LambdaMetafactory.java:503)
     	at java.base/java.lang.invoke.BootstrapMethodInvoker.invoke(BootstrapMethodInvoker.java:138)
    	... 73 more

---
Workaround:
-

    ValueChangeListener&lt;ValueChangeEvent&lt;?&gt;&gt; listener = evt -&gt; {
        // do sth with evt
    };
    ((HasValue&lt;?,?&gt;) comp).addValueChangeListener(listener);

---
System:&lt;br&gt;
OS: Windows 10&lt;br&gt;
IDE: Eclipse 2018-12 (4.10.0)&lt;br&gt;
Java (Compile): ecj&lt;br&gt;
Java (Webserver): JDK 11.0.2&lt;br&gt;
Webserver: Wildfly 15&lt;br&gt;

  [1]: https://demo.vaadin.com/javadoc/com.vaadin/vaadin-core/10.0.3/com/vaadin/flow/component/HasValue.html




Java Casting: Java 11 throws LambdaConversionException while 1.8 does not

    Exit code: 1 - javadoc: error - The code being documented uses packages in the unnamed module, but the packages defined in https://docs.oracle.com/en/java/javase/11/docs/api/ are in named modules.

Has anyone been able to make javadoc work without having to change the source version to 1.8 (as suggested in other forums)? I&#39;m using JDK v11.0.5 and the issue still present (also with JDK 12+).

Edit: This error originated from maven and thrown by the maven-javadoc-plugin. I have not been able to make it work for JDK 11+ even with the `&lt;source&gt;8&lt;/source&gt;` configuration. 

JDK 11+ and Javadoc

**Code** (spring-web 5.1.2)

    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();

        HttpHeaders headers = new HttpHeaders();
        headers.set(HttpHeaders.AUTHORIZATION, &quot;token&quot;);
        HttpEntity&lt;Object&gt; requestEntity = new HttpEntity&lt;&gt;(headers);

        ResponseEntity&lt;Object&gt; test = restTemplate.exchange(
                &quot;https://example.com&quot;,
                HttpMethod.GET,
                new HttpEntity&lt;&gt;(headers),
                new ParameterizedTypeReference&lt;&gt;() { // fails here
                });
    }

**OracleJDK 1.8** (expected output)

&gt; cannot infer type arguments for
&gt; org.springframework.core.ParameterizedTypeReference&lt;T&gt; 

&gt; reason: cannot use &#39;&lt;&gt;&#39; with anonymous inner classes

**OracleJDK 11.0.2** (not expected output)

&gt; compiler message file broken: key=compiler.misc.msg.bug
&gt; arguments=11.0.2, {1}, {2}, {3}, {4}, {5}, {6}, {7}
&gt; java.lang.NullPointerException 	at
&gt; jdk.compiler/com.sun.tools.javac.comp.Flow$FlowAnalyzer.visitApply(Flow.java:1235)
&gt; 	at
&gt; jdk.compiler/com.sun.tools.javac.tree.JCTree$JCMethodInvocation.accept(JCTree.java:1634)
&gt; 	at
&gt; jdk.compiler/com.sun.tools.javac.tree.TreeScanner.scan(TreeScanner.java:49)
&gt; 	at
&gt; jdk.compiler/com.sun.tools.javac.comp.Flow$BaseAnalyzer.scan(Flow.java:398)
&gt; 	at
&gt; jdk.compiler/com.sun.tools.javac.comp.Flow$FlowAnalyzer.visitVarDef(Flow.java:989) &lt;br/&gt;
&gt; ...

If I change diamond operator to explicit type

 `new ParameterizedTypeReference&lt;&gt;(){}` to `new ParameterizedTypeReference&lt;Object&gt;(){}`

then the code compiles successfully on both JDKs.

Is it a known compiler bug?

All Java 11 Solutions on Gang of Coders

Total of 25 Java 11 Solutions