Permanently Set Java PATH Variable on Ubuntu 22.04 Easy Setup

In this guide, you will learn to Set Java PATH Variable on Ubuntu 22.04 Permanently. The Java PATH variable is an environment variable that tells the Ubuntu system where to look for Java executable files when you run Java-related commands from the terminal.

When you type a Java command, such as java or javac, the Ubuntu system searches through directories listed in the PATH variable to find the corresponding executable file. By setting the Java PATH variable, you ensure you can run Java commands from any directory in the terminal without specifying the full path to the Java executable.

Now you can follow the rest of the article on the Orcacore website to see how to Set Java PATH Variable on Ubuntu 22.04 permanently.

To Set Java PATH Variable on Ubuntu 22.04, you must log in to your server as a non-root user with sudo privileges. To do this, you can check the Initial Server Setup with Ubuntu 22.04.

Also, we assumed that you have installed Java on your server.

Step 1 – Locate Java Installation Directory on Ubuntu 22.04

First, you need to find your Java installation path on your server. Typically, it is located under /usr/lib/jvm/ directory. Or you can use the following command to locate it:

sudo update-alternatives --config java

In my case, I get the following output:

**Example Output**
/usr/lib/jvm/java-11-openjdk-amd64/bin/java

Step 2 – Permanently Set up Java PATH Variable on Ubuntu 22.04

At this point, you can simply add the Java installation directory to your bashrc file. This will set your path variable permanently on your server. To do this, open the file with your desired text editor like Vi Editor or Nano Editor:

sudo vi ~/.bashrc

At the end of the file, add the following line with your Java installation directory:

export PATH="/path/to/java/bin:$PATH"

In my case, it looks like this:

export PATH="/usr/lib/jvm/java-11-openjdk-amd64/bin:$PATH"

When you are done, save and close the file.

Then, apply the changes with the command below:

sudo source ~/.bashrc

You can verify that the Java PATH variable is set correctly by running the command below:

echo $PATH

**Example Output**
/usr/lib/jvm/java-11-openjdk-amd64/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

That’s it, you are done with Set Java PATH Variable on Ubuntu 22.04.

Conclusion

Permanently setting up Java PATH Variable makes using Java-related commands much more convenient. Once the PATH variable is set, you can execute Java commands from any directory without having to specify the full path to the Java executable.

Also, some applications rely on the Java PATH variable being set correctly. By configuring it permanently, you ensure compatibility with these applications and avoid potential issues.

Hope you enjoy it. Also, you may like to read the following articles:

Install Default Java with APT on Ubuntu 22.04

Install Oracle JDK 21 on Ubuntu / Debian

Set and Unset Environment Variables in Linux with Examples

Fix Java Error – Failed To Validate Certificate For IPMI or KVM

FAQs

Alternative Solutions for Setting the Java PATH Variable on Ubuntu 22.04

While the .bashrc method is commonly used, there are alternative approaches to permanently setting the Java PATH variable on Ubuntu 22.04. These methods offer different levels of scope (user-specific vs. system-wide) and persistence. Let’s explore two such alternatives.

1. Using /etc/environment for a System-Wide Setting

The /etc/environment file is designed for system-wide environment variable settings. Changes to this file affect all users on the system. This is a suitable option when you need the Java PATH to be consistent across all user accounts. However, it’s crucial to understand that /etc/environment only supports simple variable assignments, not more complex shell commands.

Explanation:

This file is read by the PAM (Pluggable Authentication Modules) during the login process. It sets the environment for all users before their individual shell initialization scripts (like .bashrc) are executed.

Procedure:

1. Open the /etc/environment file with root privileges:

   sudo nano /etc/environment

2. Add or modify the PATH variable:

   Locate the existing PATH variable definition. If it doesn’t exist, add it. Append the Java installation directory to the existing PATH, ensuring proper separation with a colon (:). For example, if your current PATH looks like this:

   PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games"

   And your Java installation directory is /usr/lib/jvm/java-11-openjdk-amd64/bin, you would modify the line to:

   PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/jvm/java-11-openjdk-amd64/bin"

   Important: Do not use export in this file. /etc/environment only handles variable assignment.

3. Save and close the file.

4. Reboot or log out and log back in:

   Changes to /etc/environment only take effect after a reboot or a new login session. This is crucial; simply sourcing .bashrc won’t apply these changes.

Example:

Assuming your Java installation path is /usr/lib/jvm/java-17-openjdk-amd64/bin, the modified /etc/environment file might look like this:

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/usr/lib/jvm/java-17-openjdk-amd64/bin"
JAVA_HOME="/usr/lib/jvm/java-17-openjdk-amd64"

Caveats:

• This method sets the PATH system-wide. Be cautious when modifying system-level files.
• Changes require a reboot or logout/login to take effect.
• /etc/environment is not a shell script, so you can only assign simple variables. Don’t use commands like export or backticks.

2. Using /etc/profile.d/ for a More Flexible System-Wide Setting

The /etc/profile.d/ directory provides a more flexible way to configure system-wide environment variables compared to /etc/environment. Scripts placed in this directory are executed during the login process, allowing you to use shell commands and logic to set the Java PATH.

Explanation:

When a user logs in, the system executes the /etc/profile script. This script, in turn, typically sources all scripts within the /etc/profile.d/ directory. This provides a modular and organized way to manage system-wide environment settings.

Procedure:

1. Create a new script file in /etc/profile.d/ with root privileges:

   Choose a descriptive name for the script, such as java.sh.

   sudo nano /etc/profile.d/java.sh

2. Add the Java PATH setting to the script:

   Include the export command to set the PATH variable. You can also add additional logic or checks if needed.

   #!/bin/bash
   
   # Set Java PATH if Java is installed
   if [ -d "/usr/lib/jvm/default-java" ]; then
     export JAVA_HOME=/usr/lib/jvm/default-java
     export PATH="$JAVA_HOME/bin:$PATH"
   elif [ -d "/usr/lib/jvm/java-11-openjdk-amd64" ]; then
     export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
     export PATH="$JAVA_HOME/bin:$PATH"
   elif [ -d "/usr/lib/jvm/java-17-openjdk-amd64" ]; then
     export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
     export PATH="$JAVA_HOME/bin:$PATH"
   else
       echo "No Java installation found."
   fi

3. Make the script executable:

   sudo chmod +x /etc/profile.d/java.sh

4. Reboot or log out and log back in:

   As with /etc/environment, changes to /etc/profile.d/ only take effect after a reboot or a new login session.

Example:

The java.sh script above first checks if /usr/lib/jvm/default-java exists. If it does, it sets JAVA_HOME to that directory and adds $JAVA_HOME/bin to the PATH. It then checks for Java 11, Java 17, and if none of these are present, then it shows ‘no Java installation found’. This provides a more dynamic and adaptable approach compared to hardcoding a specific Java version.

Caveats:

• This method sets the PATH system-wide. Be cautious when modifying system-level files.
• Changes require a reboot or logout/login to take effect.
• Ensure the script is executable.
• The scripts in /etc/profile.d/ are executed during login, so keep them efficient to avoid slowing down the login process.

By understanding these alternative methods, you can choose the approach that best suits your specific needs and system configuration when you want to Set Java PATH Variable on Ubuntu 22.04 Permanently. Consider the scope (user vs. system) and the level of flexibility required when making your decision. Remember to always back up important configuration files before making changes.