I must be missing something here. 

In Java 5, the [&quot;for-each loop&quot; statement (also called the enhanced for loop)][1] was introduced. It appears that it was introduced mainly to iterate through _Collections_. Any collection (or container) class that implements the [`Iterable`][2] interface is eligible for iteration using the &quot;for-each loop&quot;. Perhaps for historic reasons, the Java arrays did not implement the `Iterable` interface. But since arrays were/are ubiquitous, `javac` would accept the use of for-each loop on arrays (generating bytecode equivalent to a traditional for loop).

In Java 8, the [`forEach` method][3] was added to the `Iterable` interface as a _default_ method. This made passing lambda expressions to collections (while iterating) possible (e.g. `list.forEach(System.out::println)`). But again, arrays don&#39;t enjoy this treatment. (I understand that there are workarounds).

Are there technical reasons why `javac` couldn&#39;t be enhanced to accept arrays in `forEach`, just like it accepts them in the enhanced for loop? It appears that code generation would be possible without requiring that arrays implement `Iterable`. Am I being naive?

This is especially important for a newcomer to the language who rather naturally uses arrays because of their syntactical ease. It&#39;s hardly natural to switch to Lists and use ```Arrays.asList(1, 2, 3)```.


  [1]: http://docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html
  [2]: https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html
  [3]: https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html#forEach-java.util.function.Consumer-

In Java 8, why were Arrays not given the forEach method of Iterable?

The Java static compiler (javac) inlines some static final variables and brings the values directly to the constant pool. Consider the following example. Class A defines some constants (public static final variables):

    public class A {
        public static final int INT_VALUE = 1000;
        public static final String STRING_VALUE = &quot;foo&quot;;
    }

Class B uses these constants:

    public class B {
        public static void main(String[] args) {
            int i = A.INT_VALUE;
            System.out.println(i);
            String s = A.STRING_VALUE;
            System.out.println(s);
        }
    }

When you compile class B, javac gets the values of these constants from class A and inlines these values in B.class. As a result, the dependency B had to class A at the compile time is erased from the bytecode. This is a rather peculiar behavior because you are baking in the values of these constants **at the time of compilation**. And you would think that this is one of the easiest things that the JIT compiler can do at runtime.

Is there any way or any hidden compiler option that lets you disable this inlining behavior of javac? For the background, we&#39;re looking into doing bytecode analysis for dependency purposes, and it is one of the few cases where bytecode analysis fails to detect compile-time dependencies. Thanks!

**Edit**: this is a vexing issue because normally we don&#39;t control all the source (e.g. third-party libraries that define constants). We&#39;re interested in detecting these dependencies from the perspective of **using** the constants. Since the reference is erased from the code that **uses** the constants, there is no easy way to detect them, short of doing source code analysis.




is it possible to disable javac&#39;s inlining of static final variables?

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?

I&#39;m working with Intellij Idea 10 and Java 6 JDK Update 7. When I run `Build --&gt; Rebuild Project` command, and the (javac) compilation generates warnings, Idea doesn&#39;t display *what* those warnings exactly are in the `Messages` view. I just see an &quot;Information: XX warnings&quot; node, but no way to expand it to see the actual warnings. Or I just see a message &quot;Compilation completed successfully with XX warnings&quot; on the status bar. For errors, Idea displays the error information (error message, filename, line number etc.) automatically. How can I get it to work similarly with warnings?

(For the record, I&#39;ve already tried using additional command line parameters such as `-Xlint`, but it does not make a difference.)

How to get Intellij Idea to display compilation warnings?

If I try to cast a `String` to a `java.util.Date`, the Java compiler catches the error. So why doesn&#39;t the compiler flag the following as an error?

    List&lt;String&gt; strList = new ArrayList&lt;&gt;();                                                                      
    Date d = (Date) strList;

Of course, the JVM throws a `ClassCastException` at runtime, but the compiler doesn&#39;t flag it.

The behavior is the same with javac 1.8.0_212 and 11.0.2.

Why does javac allow some impossible casts and not others?

Is there a way to disable restrictions of javac 1.6.0_22 that prevent me from using JRE internal classes like `sun.awt.event.*` ?

I&#39;m **not** looking for:

1. an explanation why it is forbidden.
1. suggestion to use different classes
1. suggestion to use reflection
1. suggestion to use ecj/eclipse

I just want to know if it is possible or not, and if it is then how.

Using internal sun classes with javac

There has been [some buzz](https://www.google.co.uk/search?q=site:mail.openjdk.java.net+sjavac) about a tool called `sjavac` on the OpenJDK mailing lists. Also, there are two related JEPs: [JEP 139: Enhance javac to Improve Build Speed](http://openjdk.java.net/jeps/139) and [JEP 199: Smart Java Compilation, Phase Two](http://openjdk.java.net/jeps/199).

My questions are:

- What exactly is the `sjavac` tool?
- Who is it intended for?
- How do I use it?

&lt;sup&gt;&lt;sub&gt;*Disclaimer: Self answered question. Just wanted to bring the knowledge of this tool to the StackOverflow community and to create a reference to future sjavac FAQ.*&lt;/sub&gt;&lt;/sup&gt;

What is sjavac, who is it for and how do I use it?

&lt;!-- language-all: lang-none --&gt;

I am experiencing an error while trying to compile Java programs. 

I am on Windows (this is a Windows-specific problem) and I have the latest JDK installed.

I have attempted a solution involving the `PATH` variable, but the error persists.

Console output:

    C:\&gt;set path=C:Program Files (x86)\Java\jdk1.7.0\bin
    C:\&gt;javac Hello.java
    &#39;javac&#39; is not recognized as an internal or external command,
    operable program or batch file.

javac is not recognized as an internal or external command, operable program or batch file

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?

In which languages are the Java *compiler* (`javac`), the virtual machine (JVM) and the `java` starter written?


In which language are the Java compiler and JVM written?

I have the following Java class

    public class HelloWorld {
      public static void main(String []args) {
      }
    }

When I compile this file and run a sha256 on the resulting class file I get 

&lt;!-- language: lang-none --&gt;

    9c8d09e27ea78319ddb85fcf4f8085aa7762b0ab36dc5ba5fd000dccb63960ff  HelloWorld.class

Next I modified the class and added a blank line like this: 

    public class HelloWorld {

      public static void main(String []args) {
      }
    }

Again I ran a sha256 on the output expecting to get the same result but instead I got 

&lt;!-- language: lang-none --&gt;

    11f7ad3ad03eb9e0bb7bfa3b97bbe0f17d31194d8d92cc683cfbd7852e2d189f  HelloWorld.class

I have read on [this TutorialsPoint article][1] that:

&gt; A line containing only white space, possibly with a comment, is known as a blank line, and Java totally ignores it.

So my question is, since Java ignores blank lines why is the compiled bytecode different for both programs?

Namely the difference in that in `HelloWorld.class` a `0x03` byte is replaced by a `0x04` byte.

  [1]: https://www.tutorialspoint.com/java/java_basic_syntax.htm

Why does a Java class compile differently with a blank line?

Is Eclipse&#39;s Java compiler just a wrapper around the same core that the `javac` program is wrapped around, or is it a separate compiler altogether? If the latter, why would they reinvent the wheel?

What is the difference between javac and the Eclipse compiler?

For a challenge, [a fellow code golfer](https://stackoverflow.com/users/1682559/kevin-cruijssen) [wrote the following code](https://codegolf.stackexchange.com/questions/166012/exchange-capitalization/166081?noredirect=1#comment401670_166081):

    import java.util.*;
    public class Main {
      public static void main(String[] args) {
        int size = 3;
        String[] array = new String[size];
        Arrays.fill(array, &quot;&quot;);
        for (int i = 0; i &lt;= 100;) {
          array[i++ % size] += i + &quot; &quot;;
        }
        for (String element: array) {
          System.out.println(element);
        }
      }
    }

[When running this code in Java 8, we get the following result:](https://tio.run/##TY3BTsMwEETv@YpRJKSEgFXEjZADH8CpxyoH07rVps46sjdFFcq3BzduKafdnXkz2@mTfnaD4W53nGfqB@cFXRTVKGTVY51lw/hlaYut1SHgUxPjJwOuahAtcZwc7dBHr1iLJz5sWmh/COWCAsQCRoPXejn/MV6fo87m@yZym5iPixXUnqwtFuwJeV4mb@98camkGF3Vcbw3eFnF7fYPqXlDVfXALaomMhVy5Ck//bWkpzDW9IblLcXuLetzENMrN4oaIiiWiyta3pumbJrnXw)

    1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88 91 94 97 100 
    2 5 8 11 14 17 20 23 26 29 32 35 38 41 44 47 50 53 56 59 62 65 68 71 74 77 80 83 86 89 92 95 98 101 
    3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75 78 81 84 87 90 93 96 99 

[When running this code in Java 10, we get the following result:](https://tio.run/##TY3NboMwEITvPMUIqRKU1krUWymHPkBPOUYcnMSJlpgF2UuqqOLZiYPz09Puznwz2@iTfm92x2mitu@coAmCGoSsei2TpB82lrbYWu09fjQx/hLgpnrREsapox3a4GUrccSHdQ3tDj6fUYBYwKjwUc7nP8bpc9DZ/N5FriPzfbW82pO12Yy9IU3z6O07l10rKUQXZRhfFZaLsN3/ITavqSheuEZRBaZAijTmx0dLfApjTWtYPmPs2bI6ezGt6gZRfQDFcnZD82fTmIzTdAE)

    2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 
    2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 102 
    2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 

The numbering is entirely off using Java 10. So what is happening here? Is it a bug in Java 10?

## Follow ups from the comments:

* The issue appears when compiled with Java 9 or later (we found it in Java 10). Compiling this code on Java 8, then running in Java 9 or any later version, including Java 11 early access, gives the expected result.
* This kind of code is non-standard, but is valid according to the spec. It was found by [Kevin Cruijssen](https://stackoverflow.com/users/1682559/kevin-cruijssen) in a [discussion in a **golfing challenge**](https://codegolf.stackexchange.com/questions/166012/exchange-capitalization/166081?noredirect=1#comment401670_166081), hence the weird use case encountered.
* [Didier L](https://stackoverflow.com/users/525036/didier-l) simplified the issue with this much smaller and more understandable code:
     
        class Main {
          public static void main(String[] args) {
            String[] array = { &quot;&quot; };
            array[test()] += &quot;a&quot;;
          }
          static int test() {
            System.out.println(&quot;evaluated&quot;);
            return 0;
          }
        }

   [Result when compiled in Java 8:](https://tio.run/##TYxBCoMwFET3PcWQVaRUui8eoasuxcWvBomNUZIfQcSzp6lpoYthYN7wBlroMs3KDt0rxtaQ97iTtthOwByeRrfwTJxqmXSHMTH5YKdtXzcg1/viuAJ/o6MVFTYIgf12wGOrWXmWRYNzBUHiQ/aUr15bRj78hKtnNZZT4HJOajZWCrWQCcSqE0UWO8XBWVyzbI/xDQ)

        evaluated

   [Result when compiled in Java 9 and 10:](https://tio.run/##TYxBCoMwFET3PcWQlaFUui8eoasuxcWvBomNUZIfQcSzp6lpoYthYN7wBlroMnSvGFtD3uNO2mI7AXN4Gt3CM3GqZdIdxsSKBztt@7oBud7L4wr8jY5WVNggBPbbAY@tZuW5kA3OFQSJD9lTvnptGfnwE66e1VhOgcs5qdnYQqiFTCBWnZBZ7BQHZ3HNsj3GNw)

        evaluated
        evaluated

* The issue seems to be limited to the string concatenation and assignment operator (`+=`) with an expression with side effect(s) as the left operand, like in `array[test()]+=&quot;a&quot;`, `array[ix++]+=&quot;a&quot;`, `test()[index]+=&quot;a&quot;`, or `test().field+=&quot;a&quot;`. To enable string concatenation, at least one of the sides must have type `String`. Trying to reproduce this on other types or constructs failed.


Why does array[idx++]+=&quot;a&quot; increase idx once in Java 8 but twice in Java 9 and 10?

I am using the javac compiler to compile java files in my project. The files are distributed over several packages like this: `com.vistas.util`, `com.vistas.converter`, `com.vistas.LineHelper`, `com.current.mdcontect`.

Each of these packages has several java files. I am using javac like this:

&lt;!-- language: none --&gt;

    javac com/vistas/util/*.java com/vistas/converter/*.java
          com.vistas.LineHelper/*.java com/current/mdcontect/*.java

(in one line)
 
Instead of giving so many paths, how can I ask the compiler to compile recursively all the java files from the parent com directory?

javac option to compile all java files under a given directory recursively

Most websites on the internet say:

  &gt; *&quot;use the `javac` command to compile a `.java` file. Then run it using the `java` command&quot;*

But today I tried to run a java program without `javac` and I got a strange result.

Here are the contents of a file called `hello.java`:

    public class Myclass {
     public static void main(String[] args){
        System.out.println(&quot;hello world&quot;);
      }
    }

Then I ran:

    $ javac hello.java

Which gives me this error:

    hello.java:1: error: class Myclass is public, should be declared in a file named Myclass.java
    public class Myclass {
           ^
    1 error

But when I run it without the `javac` command, it executed without any errors.
 
    $ java hello.java
    hello world

Does the `java` command also compile the program? If yes, why do we need the `javac` command?

The version of my java is:

    openjdk version &quot;12.0.2&quot; 2019-07-16
    OpenJDK Runtime Environment (build 12.0.2+10)
    OpenJDK 64-Bit Server VM (build 12.0.2+10, mixed mode)

Does the &#39;java&#39; command compile Java programs?

I tried to add the following to the root `build.gradle` file:

    subprojects {
        gradle.projectsEvaluated {
            tasks.withType(Compile) {
                options.compilerArgs &lt;&lt; &quot;-Xlint:unchecked -Xlint:deprecation&quot;
            }
        }
    }

But I&#39;m getting this:
    
    FAILURE: Build failed with an exception.
    
    * What went wrong:
    Execution failed for task &#39;:Libraries:ActionBarSherlock:compileRelease&#39;.
    &gt; invalid flag: -Xlint:unchecked -Xlint:deprecation

What am I doing wrong?

How to add -Xlint:unchecked to my Android Gradle based project?

I&#39;m trying to use `javac` with the windows command prompt, but it&#39;s not working.

After adding the directory `&quot;C:\Program Files\Java\jdk1.6.0_16\bin\&quot;` to the end of the `PATH` environment variable, the `java` command works fine, but using `javac` gives me the following error:

&gt; &#39;javac&#39; is not recognized as an internal or external command, operable program or batch file.

javac not working in windows command prompt

I get this error when I compile my java program: 

    error: Class names, &#39;EnumDevices&#39;, are only accepted if annotation 
    processing is explicitly requested
    1 error

Here is the java code (I&#39;m running this on Ubuntu).

    import jcuda.CUDA;    
    import jcuda.driver.CUdevprop;    
    import jcuda.driver.types.CUdevice;
    
    public class EnumDevices {
    
      public static void main(String args[]) {
   		 CUDA cuda = new CUDA(true);    
    		int count = cuda.getDeviceCount();
       
    		System.out.println(&quot;Total number of devices: &quot; + count);
    
    		for (int i = 0; i &lt; count; i++) {
    
    		  CUdevice dev = cuda.getDevice(i);
    		  String name = cuda.getDeviceName(dev);
    		  System.out.println(&quot;Name: &quot; + name);
    		  int version[] = cuda.getDeviceComputeCapability(dev);
    
    		  System.out.println(&quot;Version: &quot; + 
    		      String.format(&quot;%d.%d&quot;, version[0], version[1]));
    		  CUdevprop prop = cuda.getDeviceProperties(dev);
    		  System.out.println(&quot;Clock rate: &quot; + prop.clockRate + &quot; MHz&quot;);
    		  System.out.println(&quot;Threads per block: &quot; + prop.maxThreadsPerBlock);
    		}
    	}
    }

Here is the javac command:

    javac -cp /home/manish.yadav/Desktop/JCuda-All-0.3.2-bin-linux-x86_64 EnumDevices

How do I compile this program?

javac error: Class names are only accepted if annotation processing is explicitly requested

I have installed java in my *CentOS release 5.5* machine using the command `yum install java`. But I am unable to compile a class using javac.

Do I need to install any other package? 

I have tried to locate the `javac` executable but i am unable to locate it.

`/usr/bin/java` is linked as follows:  
`/usr/bin/java` -&gt; `/etc/alternatives/java`  
`/etc/alternatives/java` -&gt; `/usr/lib/jvm/jre-1.6.0-openjdk.x86_64/bin/java`

I have seen the following output by `yum list installed |grep java`:

    java-1.6.0-openjdk.x86_64              1:1.6.0.0-1.16.b17.el5          installed
    tzdata-java.x86_64                     2011b-1.el5                     installed


javac : command not found

Java 9&#39;s `javac` has a new flag `--release`:

    &gt; javac --help
    ...

    --release &lt;release&gt;
        Compile for a specific VM version. Supported targets: 6, 7, 8, 9

How is it different from `-source` and `-target` flags? Is it just a shortcut for `-source X -target X`?

What is the --release flag in the Java 9 compiler?

When using the *same JDK* (i.e. the same `javac` executable), are the generated class files always identical? Can there be a difference depending on the *operating system* or *hardware*? Except of the JDK version, could there be any other factors resulting in differences? Are there any compiler options to avoid differences? Is a difference only possibly in theory or does Oracle&#39;s `javac` actually produce different class files for the same input and compiler options?

**Update 1** I&#39;m interested in the *generation*, i.e. compiler output, not whether a class file can be *run* on various platforms.

**Update 2** By &#39;Same JDK&#39;, I also mean the same `javac` executable.

**Update 3** Distinction between theoretical difference and practical difference in Oracle&#39;s compilers.

[EDIT, adding paraphrased question]  
&quot;What are the circumstances where the same javac executable,when run on a different platform, will produce different bytecode?&quot; 

Is the creation of Java class files deterministic?

The use case is simple. I got the source files that were created using Eclipse. So, there is a deep directory structure, where any Java class could be referring to another Java class in the same, child, sibling or parent folder. 

How do I compile this whole thing from the terminal using javac ?

Java: How can I compile an entire directory structure of code ?

I&#39;m about to commit an ugly temporary hack in order to work around a blocking issue while we wait for an external resource to be fixed.  Aside from marking it with a big scary comment and a bunch of FIXMEs, I&#39;d love to have the compiler throw an obvious warning message as a reminder so we don&#39;t forget to take this out.  For example, something like:

	[javac] com.foo.Hacky.java:192: warning: FIXME temporary hack to work around library bug, remove me when library is fixed!

Is there a way I can cause an intentional compiler warning with a message of my choosing?  Failing that, what&#39;s the easiest thing to add to the code to throw an existing warning, with perhaps a message in a string on the offending line so it gets printed in the warning message?

EDIT:
Deprecated tags don&#39;t seem to be doing anything for me:

	/**
	 * @deprecated &quot;Temporary hack to work around remote server quirks&quot;
	 */
	@Deprecated
	private void doSomeHackyStuff() { ... }

No compiler or runtime errors in eclipse or from sun javac 1.6 (running from ant script), and it&#39;s definitely executing the function.



How to intentionally cause a custom java compiler warning message?

I receive the following warning:

    [javac] build.xml:9: warning: &#39;includeantruntime&#39; was not set, 
    defaulting to build.sysclasspath=last; set to false for repeatable builds

What does this mean?



ant warning: &quot;&#39;includeantruntime&#39; was not set&quot;

When i try to generate a war file, it is showing some error like 

    [ERROR] Unable to locate the Javac Compiler in:
    [ERROR] C:\Program Files\Java\jre7\..\lib\tools.jar

When i do `echo %path%` it shows

     C:\Windows\System32;D:\name\name1\Softwares\Maven\apache-maven-3.0.4\b
    in;C:\Program Files\Notepad++\;%JDK_HOME%

When i do `echo %JDK_HOME%`

    D:\name\name\core java\software\Java\Java_1.6.0_04_win\jdk1.6.0_04\bin

I don&#39;t know why maven is refering to jre, when my environmental variable is jdk. I also changes installed JRE to jdk1.6.

Maven Unable to locate the Javac Compiler in:

Im trying to compile some code in I&#39;m using Intellij Ultimate 13.1.4, but I get the following error and I have no idea what it means:

    Information:Using javac 1.7.0_55 to compile java sources
    Information:java: Errors occurred while compiling module &#39;Example&#39;
    Information:Compilation completed with 1 error and 0 warnings in 3 sec
    Information:1 error
    Information:0 warnings
    Error:java: invalid source release: 8

My guess is that its something related to Java 8 vs Java 7, but I have no idea what specifically. I&#39;ve tried to Google around for this message, but they either talk about `javac` or `target release`, so it doesn&#39;t exactly seem to apply.

Error:java: invalid source release: 8 in Intellij. What does it mean?

I need to compile a jar file using ant (1.7.0) to run under a specific version of Java (1.5). I currently have Java 1.6 on my machine. I have tried setting:

    &lt;target name=&quot;compile&quot;&gt;
      &lt;javac compiler=&quot;javac1.5&quot; target=&quot;1.5&quot; srcdir=.../&gt;
    &lt;/target&gt;

I have also removed 

    &lt;property name=&quot;build.compiler&quot; value=&quot;modern&quot;/&gt;

and there is no properties file. I am running Java 1.6 on Linux/SUSE

Also is there a simple way of determining which version of Java is expected in the jar file.


Setting the target version of Java in ant javac

Recently, I was reading this [article][1].

According to that article, Java Compiler i.e. javac does not perform any optimization while generating bytecode. Is it really true? If so, then can it be implemented as an intermediate code generator to remove redundancy and generate optimal code?


  [1]: http://www.ibm.com/developerworks/ibm/library/it-haggar_bytecode/

Optimization by Java Compiler

&lt;pre&gt;C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet&gt;dir
 Volume in drive C has no label.
 Volume Serial Number is 2041-64E7

 Directory of C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet

2009-07-02  23:54    &lt;DIR&gt;          .
2009-07-02  23:54    &lt;DIR&gt;          ..
2004-09-06  14:57               582 WelcomeApplet.html
2004-09-06  15:04             1,402 WelcomeApplet.java
               2 File(s)          1,984 bytes
               2 Dir(s)   2,557,210,624 bytes free

C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet&gt;javac WelcomeApplet.java

C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet&gt;dir
 Volume in drive C has no label.
 Volume Serial Number is 2041-64E7

 Directory of C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet

2009-07-02  23:54    &lt;DIR&gt;          .
2009-07-02  23:54    &lt;DIR&gt;          ..
2009-07-02  23:54               975 WelcomeApplet$1.class
2009-07-02  23:54             1,379 WelcomeApplet.class
2004-09-06  14:57               582 WelcomeApplet.html
2004-09-06  15:04             1,402 WelcomeApplet.java
               4 File(s)          4,338 bytes
               2 Dir(s)   2,557,202,432 bytes free

C:\Program Files\Java\jdk1.6.0_05\CoreJava\v1\v1ch2\WelcomeApplet&gt;
&lt;/pre&gt;


Here is the content of that Java file:

    /**
       @version 1.21 2002-06-19
       @author Cay Horstmann
    */
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    import java.net.*;
    
    public class WelcomeApplet extends JApplet
    {
       public void init()
       {
          setLayout(new BorderLayout());
    
          JLabel label = new JLabel(getParameter(&quot;greeting&quot;), SwingConstants.CENTER);
          label.setFont(new Font(&quot;Serif&quot;, Font.BOLD, 18));
          add(label, BorderLayout.CENTER);
    
          JPanel panel = new JPanel();
    
          JButton cayButton = new JButton(&quot;Cay Horstmann&quot;);
          cayButton.addActionListener(makeURLActionListener(
             &quot;http://www.horstmann.com&quot;));
          panel.add(cayButton);
    
          JButton garyButton = new JButton(&quot;Gary Cornell&quot;);
          garyButton.addActionListener(makeURLActionListener(
             &quot;mailto:gary@thecornells.com&quot;));
          panel.add(garyButton);
    
          add(panel, BorderLayout.SOUTH);
       }
    
       private ActionListener makeURLActionListener(final String u)
       {
          return new
             ActionListener()
             {
                public void actionPerformed(ActionEvent event)
                {
                   try
                   {
                      getAppletContext().showDocument(new URL(u));
                   }
                   catch(MalformedURLException e) 
                   { 
                      e.printStackTrace(); 
                   }
                }
             };
       }
    }



What is the $1 in class file names?

I am having a pathetic issue with Java in my mac osx 10.7.3 .
Previously I installed it and it was working fine.
After some changes in the .bash_profile and .profile file in the course of time,
I am having an error like 

    Unable to locate an executable at &quot;/usr/bin/java/bin/java&quot;


whenever I try to run &quot;javac&quot; or &quot;java&quot; in my terminal .

`echo $PATH` gives an output like :

    /usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/Users/sabya/Documents/Play_Framework/play-2.0:/usr/X11/bin:/usr/local/git/bin:/usr/local/mysql/bin



My .bash_profile looks like :

    alias start_mysql=&quot;/Library/StartupItems/MySQLCOM/MySQLCOM start&quot;
    alias stop_mysql=&quot;/Library/StartupItems/MySQLCOM/MySQLCOM stop&quot;
    export JAVA_HOME=/usr/bin/java


Output of `which java`

    /usr/bin/java


Its bugging me for long days and uninstalling and installing java did not help my luck .

I am a newbie in Mac and need help to sort out this issue .

Googled and saw SOF before posting this question but did not find anything specific to my problem .

Thanks 

Sabya

Unable to locate an executable at &quot;/usr/bin/java/bin/java&quot; (-1)

If I switch on the generating of debug info with Javac then the class files are 20-25% larger. Has this any performance effects on running the Java program? If yes on which conditions and how many. I expect a little impact on loading the classes because the files are larger but this should be minimal.

Is there a performance difference between Javac debug on and off?

I have an Ant file that compiles my program. I want the javac task to fail if any warning was reported by the compiler. Any clue on how to do that?



Make javac treat warnings as errors

I know running `javac file1.java` produces `file1.class` if `file1.java` is the only source file, then I can just say `java file1` to run it.

However, if I have 2 source files, `file1.java` and `file2.java`, then how  do I build the program?




How to compile multiple java source files in command line

Is this valid Java?

    import java.util.Arrays;
    import java.util.List;

    class TestWillThatCompile {

        public static String f(List&lt;String&gt; list) {
            System.out.println(&quot;strings&quot;);
            return null;
        }

        public static Integer f(List&lt;Integer&gt; list) {
            System.out.println(&quot;numbers&quot;);
            return null;
        }

        public static void main(String[] args) {
            f(Arrays.asList(&quot;asdf&quot;));
            f(Arrays.asList(123));
        }

    }


- Eclipse 3.5 says **yes**  
- Eclipse 3.6 says **no**  
- Intellij 9 says **yes**  
- Sun javac 1.6.0_20 says **yes**  
- GCJ 4.4.3 says **yes**    
- GWT compiler says **yes**    
- Crowd at my [previous Stackoverflow question][1] says **no**

My java theory understanding says **no**!

It would be interesting to know what [the JLS][2] is saying about it.  

  [1]: https://stackoverflow.com/questions/3105177/why-is-one-class-valid-while-the-other-is-not
  [2]: http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html

Is this valid Java?

Consider the following code

    public class JDK10Test {
        public static void main(String[] args) {
            Double d = false ? 1.0 : new HashMap&lt;String, Double&gt;().get(&quot;1&quot;);
            System.out.println(d);
        }
    }

When running on JDK8, this code prints `null` whereas on JDK10 this code results in `NullPointerException`

    Exception in thread &quot;main&quot; java.lang.NullPointerException
	    at JDK10Test.main(JDK10Test.java:5)

The bytecode produced by the compilers is almost identical apart from two additional instructions produced by the JDK10 compiler which are related to autoboxing and seem to be responsible for the NPE.

    15: invokevirtual #7                  // Method java/lang/Double.doubleValue:()D
    18: invokestatic  #8                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;


Is this behaviour a bug in JDK10 or an intentional change to make the behaviour stricter? 

    JDK8:  java version &quot;1.8.0_172&quot;
    JDK10: java version &quot;10.0.1&quot; 2018-04-17
   





Difference in behaviour of the ternary operator on JDK8 and JDK10

**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?

JDK 11.0.2 compilation fails with javac NPE on anonymous parameterized class type inference

When I compile, javac outputs:

    Note: Some input files use or override a deprecated API.
    Note: Recompile with -Xlint:deprecation for details.`

I wish to suppress this warning. Trying -Xlint:none does not seem to help.

How can I suppress javac warnings about deprecated api?

When I compile the Spring JDBC source on OS X with JDK 1.7.0, I get this warning:

    warning: CachedRowSetImpl is internal proprietary API and may be removed in a future release

How do I suppress the warning message during a compile?

I already know and use Java&#39;s @SuppressWarning annotations. I&#39;m looking for the specific use of this to suppress the warning I&#39;ve described.

My question specifically is, in this line of code:

    @SuppressWarnings(&quot;valuegoeshere&quot;)

what should &quot;valuegoeshere&quot; be replaced with?

EDIT: People, I know that it is best to avoid the code that leads to the warning. And usually that would be my approach. However I&#39;m compiling third-party code here which I don&#39;t want to rewrite. I just want to add the correct annotation to suppress the warning, so that warnings I can actually do something about don&#39;t get buried.

All Javac Solutions on Gang of Coders

Total of 38 Javac Solutions