How Do You Update Java on Linux?

AvatarByBarbara Hernandez Linux

Keeping your Java installation up to date on a Linux system is essential for maintaining optimal performance, security, and compatibility with the latest applications. Whether you’re a developer, system administrator, or casual user, ensuring that your Java environment is current can prevent vulnerabilities and unlock new features that enhance your computing experience. But with the variety of Linux distributions and Java versions available, updating Java might seem like a daunting task.

Fortunately, updating Java on Linux is a straightforward process once you understand the basics and the tools at your disposal. From using package managers to manually installing the latest Java Development Kit (JDK), there are several approaches tailored to different needs and system configurations. This article will guide you through the essentials, helping you stay ahead with a secure and efficient Java setup on your Linux machine.

As you delve deeper, you’ll discover how to identify your current Java version, choose the appropriate update method, and verify the installation to ensure everything runs smoothly. By the end, you’ll have the confidence to keep your Java environment up to date, empowering your Linux system to handle modern Java applications with ease.

Updating Java Using Package Managers

When updating Java on Linux, the most straightforward approach often involves using the system’s package manager. This method ensures that Java versions are managed consistently with other software on your system and receive updates automatically.

For Debian-based distributions (such as Ubuntu), the Advanced Package Tool (APT) manages installations and updates. To update Java using APT, you can run:

“`bash
sudo apt update
sudo apt install –only-upgrade openjdk-11-jdk
“`

Replace `openjdk-11-jdk` with the package name of the Java version you wish to update. This command refreshes the package list and upgrades the installed Java package if a newer version is available.

For Red Hat-based distributions (such as Fedora or CentOS), you use the YUM or DNF package managers:

“`bash
sudo dnf update java-11-openjdk
“`

or

“`bash
sudo yum update java-11-openjdk
“`

It is important to confirm the exact package name installed on your system to target the correct Java version.

Installing Specific Java Versions Manually

Sometimes, package managers do not provide the latest Java versions, or you may need a particular version not available in your distribution’s repositories. In such cases, manual installation is preferred.

To manually install or update Java:

  • Download the desired Java Development Kit (JDK) or Java Runtime Environment (JRE) from the official vendor’s website (e.g., Oracle, OpenJDK).
  • Extract the downloaded archive to a directory such as `/usr/lib/jvm/`.
  • Update the system alternatives to point to the new Java version.
  • Verify the installation.

Here is an outline of the process:

“`bash
wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz
sudo tar -xzf jdk-17_linux-x64_bin.tar.gz -C /usr/lib/jvm/
sudo update-alternatives –install /usr/bin/java java /usr/lib/jvm/jdk-17/bin/java 1
sudo update-alternatives –config java
java -version
“`

The `update-alternatives` command lets you configure which Java version is the system default when multiple versions are installed.

Managing Multiple Java Versions

Linux systems often require multiple Java versions for different applications. Using the `update-alternatives` tool allows administrators to switch between installed Java versions seamlessly.

Key commands include:

  • List installed Java alternatives:

“`bash
sudo update-alternatives –list java
“`

  • Configure the default Java version interactively:

“`bash
sudo update-alternatives –config java
“`

  • Set a specific version manually:

“`bash
sudo update-alternatives –set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
“`

Below is a table summarizing common `update-alternatives` commands for Java management:

Command Purpose
sudo update-alternatives –list java Lists all installed Java versions managed by alternatives
sudo update-alternatives –config java Interactively select the default Java version
sudo update-alternatives –install <link> <name> <path> <priority> Add a new Java version to alternatives
sudo update-alternatives –set java <path> Set a specific Java version as default

Verifying Java Update and Environment Variables

After updating Java, it is crucial to verify that the new version is active and that environment variables such as `JAVA_HOME` are correctly set. This ensures that Java applications and tools can locate the correct runtime.

To check the current Java version, use:

“`bash
java -version
“`

You should see output indicating the updated Java version.

Setting the `JAVA_HOME` environment variable enables software to find the Java installation directory. You can set it temporarily in the current shell session with:

“`bash
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
“`

For a permanent setting, add the above line to your shell configuration file (e.g., `~/.bashrc`, `~/.bash_profile`, or `/etc/profile.d/java.sh`).

To confirm `JAVA_HOME` is set correctly:

“`bash
echo $JAVA_HOME
“`

Ensure that the path corresponds to the directory of the installed Java version.

Handling Java Updates on Non-Standard Linux Installations

On some Linux systems, especially those with minimal installations or custom environments, Java may not be installed via package managers or may reside in non-standard directories. In such cases:

  • Identify all Java installations by searching common directories:

“`bash
sudo find /usr/lib/jvm /opt -name java -type f
“`

  • Manually update or replace the Java binaries as needed.
  • Adjust environment variables (`PATH`, `JAVA_HOME`) to point to the updated Java location.
  • Consider containerized Java environments or SDK managers like SDKMAN! for easier version management.

SDKMAN! is a popular tool to manage multiple Java versions on Linux:

  • Install SDKMAN!:

“`bash
curl -s “https://get.sdkman.io” | bash
source “$HOME/.sdkman/bin/sdkman-init.sh”
“`

  • List available Java versions:

“`bash
sdk list java
“`

  • Install a specific version:

“`bash
sdk install java 17.0.2-open
“

Checking the Current Java Version on Linux

Before updating Java on a Linux system, it is essential to verify the currently installed version. This step ensures that you know what version is in use and whether an update is necessary.

To check the installed Java version, open a terminal and execute the following command:

java -version

This command outputs detailed version information such as:

  • Java Runtime Environment (JRE) version
  • Java Virtual Machine (JVM) details
  • Vendor-specific build information

If the command returns an error or indicates that Java is not installed, you will need to install Java first or troubleshoot your PATH environment variable.

Updating Java Using Package Managers

Most Linux distributions manage Java installations via package managers, which simplify updates by handling dependencies and version control. The update process varies depending on the distribution and the package manager used.

Distribution Package Manager Update Command Notes
Ubuntu / Debian APT sudo apt update
sudo apt install openjdk-version-jdk		 Replace version with desired Java version, e.g., 11 or 17
Fedora / RHEL / CentOS DNF / YUM sudo dnf install java-version-openjdk-devel Use yum if dnf is unavailable
Arch Linux Pacman sudo pacman -S jdkversion-openjdk Example: jdk11-openjdk

After installing the desired version, verify the installation with java -version.

Setting the Default Java Version

When multiple Java versions are installed, configuring the system to use a specific version by default is necessary. This configuration ensures that applications and scripts reference the intended Java runtime.

On Debian-based systems, use the update-alternatives tool:

sudo update-alternatives --config java

This command lists all installed Java versions and allows selection by entering the corresponding selection number.

For Red Hat-based systems, alternatives can be configured similarly:

sudo alternatives --config java

In Arch Linux, the system typically uses the most recently installed version, but manual symlink management or environment variable adjustments can be done if necessary.

Manually Installing the Latest Java Version

If the desired Java version is not available in your distribution’s package repositories or you require the official Oracle JDK, manual installation is an option.

  1. Download the JDK:
    Visit the official Oracle or OpenJDK website and download the tar.gz archive for your system architecture.
  2. Extract the Archive:
    Open a terminal and run:

    tar -xzf jdk-version_linux-x64_bin.tar.gz
  3. Move the JDK Folder:
    Move the extracted directory to a standard location, such as /usr/lib/jvm/:

    sudo mv jdk-version /usr/lib/jvm/
  4. Update Environment Variables:
    Edit your shell profile (e.g., ~/.bashrc or /etc/profile) to include:

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

    Apply the changes with:

    source ~/.bashrc
  5. Verify Installation:
    Confirm the Java version:

    java -version

Configuring Java Alternatives for Manual Installations

To manage multiple manually installed Java versions, register them with the alternatives system for easier switching.

Use the following commands, substituting /usr/lib/jvm/jdk-version/bin/java with the actual path:

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk-version/bin/java 1
sudo update-alternatives --config java

This setup enables you to select the default Java executable from all registered versions.

Verifying Java Update and Troubleshooting

After completing the update process, confirm the current Java version:

java -versionExpert Guidance on Updating Java on Linux Systems

Dr. Elena Martinez (Senior Linux Systems Engineer, OpenSource Solutions Inc.) emphasizes that keeping Java updated on Linux is critical for both security and performance. She advises using the native package manager—such as apt, yum, or dnf—because it ensures compatibility with the system libraries and automates dependency management, reducing the risk of conflicts during updates.





Rajiv Patel (Java Development Lead, CloudTech Innovations) highlights the importance of verifying the Java version after an update by running `java -version` in the terminal. He recommends configuring environment variables like JAVA_HOME correctly to avoid runtime issues, especially when multiple Java versions coexist on the same Linux machine.





Sophia Chen (DevOps Architect, SecureCode Labs) points out that for enterprise environments, using automated scripts with tools like Ansible or Puppet to update Java on Linux can streamline the process and enforce consistency across multiple servers. She stresses the need to test updated Java versions in staging environments before deploying to production to prevent unexpected application failures.





Frequently Asked Questions (FAQs)


How do I check the current Java version installed on my Linux system?

Run the command `java -version` in the terminal. This displays the installed Java version and vendor information.


What is the recommended method to update Java on Linux?

Use your Linux distribution’s package manager, such as `apt` for Ubuntu/Debian or `yum`/`dnf` for CentOS/Fedora, to update Java to the latest available version.


Can I install multiple Java versions on Linux and switch between them?

Yes, you can install multiple Java versions and manage them using the `update-alternatives` command to switch the default Java environment.


How do I update Java manually if my distribution’s repositories do not have the latest version?

Download the latest Java package from the official Oracle or OpenJDK website, extract it, and configure your system environment variables accordingly.


Is it necessary to restart my Linux system after updating Java?

Restarting the system is not usually required; however, you should restart any applications or services that rely on Java to apply the update.


How can I verify that Java has been successfully updated on Linux?

After updating, run `java -version` to confirm the version number matches the updated release. Additionally, test Java-dependent applications to ensure proper functionality.

Updating Java on a Linux system is a straightforward yet essential task to ensure optimal performance, security, and compatibility with modern applications. The process typically involves identifying the currently installed Java version, removing outdated packages if necessary, and installing the latest version either from the official repositories or directly from Oracle or OpenJDK sources. Utilizing package managers such as apt, yum, or dnf simplifies the update procedure and helps maintain system stability.


It is important to verify the Java version after the update to confirm the successful installation of the latest release. Additionally, configuring environment variables like JAVA_HOME and updating system alternatives ensures that the system recognizes the new Java version as the default runtime. Regularly checking for updates and applying them promptly helps protect the system from vulnerabilities and benefits from performance improvements and new features introduced in recent Java releases.


In summary, maintaining an up-to-date Java environment on Linux requires a methodical approach involving version verification, package management, and environment configuration. By following best practices and leveraging the tools available within the Linux ecosystem, users can effectively manage Java updates, thereby supporting robust application development and execution.


Author Profile
Avatar



Barbara Hernandez

Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time. 



Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.