Published on

Mastering the Essential Java Command Line Tools


As a Java developer, mastering the command line tools is essential for efficient coding, debugging, and managing Java applications. In this guide, we will explore the basic use of the java command and its associated tools that every Java developer should know.

1. Checking Your Java Version

Before you start any Java development work, it's crucial to confirm your Java installation's version:

java -version

This command displays information about the installed Java version. Ensuring the correct version is in place is the first step in avoiding compatibility issues.

2. Getting Help

Whenever you need a quick reference for the available options and usage of the java command, use the -help option:

java -help

This command provides a concise summary of the available options, which can be invaluable for navigating the java command's extensive capabilities.

3. Compiling Java Code with javac

To compile your Java source code into bytecode that the Java Virtual Machine (JVM) can execute, you'll need to use the javac command:


This command generates .class files that are ready for execution.

4. Running Java Applications

Once your Java code is compiled, you can execute it using the java command:

java YourMainClass

This command launches your Java application, and you should see the program's output in the console.

5. Passing Command-Line Arguments

Java applications often accept input from the command line. You can pass arguments to your Java program like this:

java YourMainClass arg1 arg2 arg3

These arguments can be accessed within your Java code through the args array in the main method.

6. Specifying the Classpath with -cp

The -cp (or -classpath) option allows you to specify the classpath, which tells the JVM where to find classes and resources:

java -cp path/to/your/library.jar YourMainClass

This ensures that your application can access the necessary classes and resources.

7. Running Executable JARs with -jar

Executable JAR files simplify the distribution of Java applications. Execute them using the -jar option:

java -jar YourApp.jar

This command extracts the main class and other metadata from the JAR's manifest file.

8. Defining System Properties with -Dproperty=value

You can configure your Java application at runtime by specifying system properties:

java YourMainClass

This is useful for dynamically adjusting your application's behavior.

9. Memory Management with -Xmx, -Xms, and -Xss

Fine-tuning memory allocation is crucial for Java applications:

  • -Xmx sets the maximum heap size, e.g., -Xmx512m.
  • -Xms sets the initial heap size, e.g., -Xms256m.
  • -Xss adjusts the thread stack size, e.g., -Xss256k.

These options are essential for optimizing memory usage, especially in memory-intensive applications.

10. Activating Assertions with -ea

To catch and handle bugs early in the development process, activate assertions in your code with -ea:

java -ea YourMainClass

Assertions ensure that your code behaves as expected.

11. Enabling Verbose Output with -verbose:g

For in-depth debugging and performance analysis, enable verbose output for garbage collection with -verbose:g:

java -verbose:g YourMainClass

This option provides detailed information about garbage collection activities.

12. Debugging with -Xdebug and -Xrunjdwp

For advanced debugging scenarios, enable Java Debug Wire Protocol (JDWP) with these options:

java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 YourMainClass

This allows you to connect a debugger for comprehensive debugging sessions.

By mastering these basic uses of the java command and its associated options, you'll be well-equipped to develop, test, and troubleshoot Java applications efficiently. As you progress in your Java development journey, you'll discover even more advanced capabilities of these essential tools. Happy coding!