How to Run Java from the Command Line in Linux like a Pro

As a full-stack developer and Java expert with over 10 years of experience, I firmly believe that Linux and Java form an incredibly powerful combination for building cutting-edge software applications.

In this comprehensive technical guide, I will provide insider tips and detailed instructions on running Java code like a pro from the Linux command line interface (CLI).

So let‘s get started!

Why Run Java from Linux Command Line?

Here are some key reasons why Linux terminal offers the best development environment for writing Java programs:

• Fast Iterations: The CLI workflow allows rapid cycles of coding, testing and debugging without unnecessary project setup or IDE clutter. You can focus on problem-solving instead of GUI clicks.

• Powerful Tools Integration: Linux commands like grep, awk, sed, pipes etc. perfectly complement Java tools like javac, jar, jstack etc. enabling creation of an extremely productive workflow.

• Enhanced Control: Direct access to JVM Internals by monitoring threads, memory, statistics etc. helps build robust and optimized applications.

• Specialized Environments: Easy to replicate production servers by running Java apps from Docker containers, remote servers via SSH without local installation hassles.

• Automation Simplified: Scripting application builds, tests deployment procedures improves consistency. Scheduling recurring tasks further simplifies developer operations.

As per the 2021 Developer Survey by StackOverflow, over 71% of professional developers use Terminals or CLI in some form for coding making it an essential mainstream skill.

Step-by-Step Guide to Run Java Programs

Here is a step-by-step expert guide on setting up your Linux environment for compiling and running Java apps smoothly from the command line:

Install and Configure Java

The prerequisites are a Linux OS (I use Ubuntu for this guide) and an installation of the Java Development Kit (JDK version 8 or higher). Oracle and OpenJDK are popular Java environments used professionally.

First, update the package indexes and install default Java packages using:

sudo apt update
sudo apt install default-jdk

This will install Java from your distro‘s repositories.

Alternatively, you can directly get the latest JDK from Oracle or AdoptOpenJDK sites and set it up accordingly. Using a JDK version manager like SDKMAN is also highly recommended.

Next, check the version to validate everything is installed correctly by running:

java -version

This will print details like Java vendor, runtime version and JVM details.

Furthermore, set JAVA_HOME and update PATH variable to point to the base JDK installation directory in the ~/.profile file:

export JAVA_HOME=/usr/lib/jvm/jdk-11
export PATH=$PATH:$JAVA_HOME/bin

Load the changes either by directly sourcing the file or opening a new terminal.

Hooray! Your Linux environment is now ready to build awesome Java apps from the CLI.

Write Your First Java Class

It‘s coding time now!

Open up your favorite text editor or terminal-based IDE like Vim or Emacs.

You can use an IDE, but real masters create Java magic with just their trusted editor and terminal ☕.

Write a simple Java class with a main method that prints "Hello World!":

public class Main {

  public static void main(String[] args) {
    System.out.println("Hello Java World!");  
  }

}

Remember to name the source file as Main.java to match the public class name.

Time to run this code.

Compile and Execute

Switch to the terminal and navigate to the directory containing your Java file using the cd command.

Then invoke the javac compiler to build the class files from your source code:

javac Main.java

This creates a Main.class byte code file if compiled successfully.

Now for the moment of truth – execute your Java program using:

java Main

If everything went well, it will proudly print Hello Java World! – your first Java program from terminal!

Let‘s enhance this example…

Pass Command Line Arguments

One of the powers of running Java apps from terminal is the ability to pass dynamic arguments easily from the command line.

Modify Main.java as:

public class Main {

  public static void main(String[] args) {
    System.out.println("Hello " + args[0]);  
  }

}

Then recompile and run the program while passing a name argument:

javac Main.java
java Main John

This will print Hello John!

You can pass multiple arguments separated by spaces and access them easily in your code via the String array args parameter of main().

This enables creating parameterized applications and scripts avoiding unnecessary code changes.

Interactive Java REPL

Ruby has IRB, Python has IPython and Node.js has repl. Java has something similar too – the jshell REPL (Read-Eval-Print-Loop).

This interactive shell introduced in Java 9 allows evaluating code snippets directly from terminal.

Let‘s try printing a Hello Message with jShell:

jshell
|  Welcome to JShell -- Version 11.0.17
|  For an introduction type: /help intro

jshell> System.out.println("Hello JShell");
Hello JShell

jshell> 

It‘s that easy! You can input multiline code, variables assignments, method calls etc. without needing to write complete classes or main methods.

This quick feedback loop combined with Linux pipes and commands is perfect for fast prototyping.

Some ways you can use jShell productively:

• Test API calls to Java libraries
• Experiment with syntax structures
• Validate regular expressions
• Teach Java interactively

Shells are a magician‘s wand enabling REPL driven development – an important modern software engineering practice.

Level Up with Java Development Tools

Now that you know running and testing Java codes let‘s explore some advanced CLI tools that will level up your skills:

javac – The Java Compiler

This standard command line compiler available with any JDK allows building Java source files into bytecodes.

Some lesser-known useful switches worth remembering are:

1. Enable Debug Symbols and Lines Info:

javac -g Main.java  

2. Set Specific Target JDK Version:

javac -source 1.5 Main.java

Useful for compatibility testing.

3. Batch Compile Multiple Files:

javac MyClass.java MyInterface.java Utils.java

No need to compile one by one!

jar – Java Archives Utility

This is used to bundle multiple Java class files and resources into a single compressed JAR file for distribution.

Some handy usage examples are:

1. Create JAR

jar cvf MyApp.jar *.class

2. List JAR Contents

jar tvf MyApp.jar 

3. Run JAR Application

java -jar MyApp.jar

This executes the main class within the JAR if configured correctly.

Furthermore, you can integrate JARs with shell scripts, load dynamically at runtime, attach MANIFEST metadata and tons more.

jdeprscan – Find Deprecated Java APIs

One problem with legacy Java projects is usage of deprecated or obsolete classes and methods. These should be avoided to prevent future issues when support stops completely.

jdeprscan Main.class

This scans your code and highlights deprecated symbols used. Really helpful before upgrading JDK versions!

Some other Useful Diagnostic Commands are:

• jstack – Print Java Thread Stack Traces
• jmap – Create Heap Dumps
• jstat – JVM Statistics Monitoring
• jconsole – GUI based Visualization

Mastering these advanced commands will give you greater visibility into Java applications enhancing your debugging and optimization skills.

Terminal-Based Java IDEs

For heavy coding workloads, CLI centric IDEs like Eclipse Vert.x, Visual Studio Code, vim/emacs etc. combined with terminal windows offer the flexibility.

I have used Eclipse, IntelliJ and NetBeans in the past – they are very feature rich withGUI widgets and visual tools.

But now I mostly leverage VS Code + Java extensions + Integrated Terminal instead for faster coding. This brings fluid terminal control alongside modern editor benefits.

Some ways you can utilize VS Code terminal for streamlining Java development:

• Run Maven builds and see errors in real-time
• Stream application logs using tail
• Debug code with gdb debugger integration
• Install dependencies without switching apps
• SSH remote servers to check production instances
• Containerize applications easily using Docker

Modern terminal-based coding setups reduce context switching and deliver high productivity for programmers.

Wrapping Up

In this extensive guide, I have covered the entire route of running Java programs from Linux command line – including tools, techniques and best practices utilized by professionals.

To conclude, here is a quick rundown of the advantages:

✅ Combine power of Java and Linux for faster coding cycles

✅ Tight integration with DevOps toolchain – Git, CI/CD, Containers etc.

✅ Leverage shell commands with Java tools for advanced workflows

✅ Enhanced application monitoring, debugging and profiling

✅ Customize environments to match production servers

I hope you found this detailed tutorial valuable. Implementing these learnings will level up your Java skills and efficiency.

So open your favorite terminal emulator, IDE or code editor…and let the Java coding begin!