How to set Java environment path in Ubuntu

Question

I just installed JDK in Ubuntu with sudo apt-get install openjdk-6-jdk command, after the installation where's the Java bin directory located? And how can I set the environment path for that directory? I have little experience with Ubuntu, can anyone give some advice or suggest any good website for reference?

Couplet

Answer 1

set environment variables as follows

Edit the system Path file /etc/profile

sudo gedit /etc/profile

Add following lines in end

JAVA_HOME=/usr/lib/jvm/jdk1.7.0
PATH=$PATH:$HOME/bin:$JAVA_HOME/bin
export JAVA_HOME
export JRE_HOME
export PATH

Then Log out and Log in ubuntu for setting up the paths...

Esculent

why export JRE_HOME? – Bloater

It didn't work for me and the previous version remained as default. I changed the order of the path to export PATH=${JAVA_HOME}/bin:${PATH} and the version got updated. I think left to right priority works here. – Pony

Already solved here #24642036 – Posada

.bash_profile and .bashrc are specific to bash, whereas .profile is read by many shells in the absence of their own shell-specific config files. /etc/bash_profile (fallback /etc/profile) is read before the user's .profile for system-wide configuration. – Acceptant

Also you would have to logout and login for the changes to take effect for /etc/profile but only close and open a new terminal if you change ~/.bashrc – Acceptant

Just add this... export JAVA_HOME=$HOME/.local/jbr export PATH=$PATH:$HOME/bin:$JAVA_HOME/bin – Margravine

Answer 2

Java is typically installed in /usr/java locate the version you have and then do the following:

Assuming you are using bash (if you are just starting off, i recommend bash over other shells) you can simply type in bash to start it.

Edit your ~/.bashrc file and add the paths as follows:

for eg. vi ~/.bashrc

insert following lines:

export JAVA_HOME=/usr/java/<your version of java>
export PATH=${PATH}:${JAVA_HOME}/bin

after you save the changes, exit and restart your bash or just type in bash to start a new shell

Type in export to ensure paths are right.

Type in java -version to ensure Java is accessible.

Ideography

perfect! thank you. NB: You might want to remove the default openJDK from your system as it appears first in the global path. So after the above script is loaded, you will only pic-up "javac" not java, because of the default openjk-jre. ~sudo apt-get remove openjdk-*~ – Congeal

I have probelm with it, I tried every method to update java, but still time my version is jdk1.7 but I set up the path to jdk1.8 – Stableboy

source ~/.bashrc restart bash without logout. – Reactance

Answer 3

Ubuntu installs openjdk6 to /usr/lib/jvm/java-6-openjdk path. So you will have the bin in /usr/lib/jvm/java-6-openjdk/bin. Usually the classpath is automatically set for the java & related executables.

Willettawillette

It seems like you can use /usr/lib/jvm/default-java as well, correct? – Babism

Answer 4

To Set JAVA_HOME / PATH for a single user, Login to your account and open .bash_profile file

$ vi ~/.bash_profile

Set JAVA_HOME as follows using syntax export JAVA_HOME=<path-to-java>. If your path is set to /usr/java/jdk1.5.0_07/bin/java, set it as follows:

export JAVA_HOME=/usr/java/jdk1.5.0_07/bin/java

Set PATH as follows:

export PATH=$PATH:/usr/java/jdk1.5.0_07/bin

Feel free to replace /usr/java/jdk1.5.0_07 as per your setup. Save and close the file. Just logout and login back to see new changes. Alternatively, type the following command to activate the new path settings immediately:

$ source ~/.bash_profile

OR

$ . ~/.bash_profile

Verify new settings:

$ echo $JAVA_HOME
$ echo $PATH

Tip: Use the following command to find out exact path to which java executable under UNIX / Linux:

$ which java

Please note that the file ~/.bashrc is similar, with the exception that ~/.bash_profile runs only for Bash login shells and .bashrc runs for every new Bash shell.

To Set JAVA_HOME / PATH for all user, You need to setup global config in /etc/profile OR /etc/bash.bashrc file for all users:

# vi /etc/profile

Next setup PATH / JAVA_PATH variables as follows:

export PATH=$PATH:/usr/java/jdk1.5.0_07/bin
export PATH=$PATH:/usr/java/jdk1.5.0_07/bin

Save and close the file. Once again you need to type the following command to activate the path settings immediately:

# source /etc/profile

OR

# . /etc/profile

Choker

Are you sure you're supposed to set JAVA_HOME to the java binary? – Cloutier

Answer 5

You need to set the $JAVA_HOME variable.

In my case while setting up Maven, I had to set it up to where JDK is installed.

First find out where JAVA is installed:

$ whereis java

java: /usr/bin/java /usr/share/java /usr/share/man/man1/java.1.gz

Now dig deeper:

$ ls -l /usr/bin/java

lrwxrwxrwx 1 root root 46 Aug 25 2018 /etc/alternatives/java -> /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java

Dig deeper:

$ ls -l /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java

-rwxr-xr-x 1 root root 6464 Mar 14 18:28 /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java

As it is not being referenced to any other directory, we'll use this.

Open /etc/environment using nano:

$ sudo nano /etc/environment

Append the following lines

JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-amd64

export JAVA_HOME

Reload PATH using:

$. /etc/environment

Now:

$ echo $JAVA_HOME

Here is your output:

/usr/lib/jvm/java-1.8.0-openjdk-amd64

Sources I referred to:

https://askubuntu.com/a/175519

https://mcmap.net/q/120546/-where-is-the-java-sdk-folder-in-my-computer-ubuntu-12-04

Bernardinabernardine

To dig deeper, you can use readlink -f /usr/bin/java as well – Lunn

Answer 6

if you have intalled only openJDK, the you should update your links, because you can have some OpenJDK intallation.

sudo update-alternatives --config java

after this

$gedit ~/.bashrc

add the following line in the file

JAVA_HOME=/usr/lib/jvm/YOUR_JAVA_VERSION export PATH=$PATH:$JAVA_HOME/bin export JAVA_HOME

you can get you java version with

java -version

Modest

Answer 7

How to install java packages:

Install desired java version / versions using official ubuntu packages, which are managed using alternatives:
sudo apt install -y openjdk-8-jdk
or/and other version: sudo apt install -y openjdk-11-jdk

Above answers are correct only when you have only one version for all software on your machine, and you can skip using update-alternatives. So one can quickly hardcode it in .bashrc or some other place:
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-amd64
but it's not healthy, as later on you may change the version.

Correct way to set JAVA_HOME (and optionally JAVA_SDK, JAVA_JRE )

The correct way (and mandatory when you have more than one), is to detect what update-alternative is pointing to, and always use update-alternatives to switch active version.

Here are the suggestions for both: only specific unix account or for all accounts (machine level).

1. for a specific unix account only:

Use this if you don't have permissions to do it at machine level.

cat <<'EOF' >>~/.bashrc

export JAVA_HOME=$(update-alternatives --query java | grep Value | cut -d" " -f2 | sed 's!\(\/.*\)jre\(.*\)!\1!g')
export JDK_HOME=${JAVA_HOME}
export JRE_HOME=${JDK_HOME}/jre/

EOF

2. To do it at machine level, and for all bourne shells, you need 2 steps:

2.a

cat <<'EOF' | sudo tee /etc/profile.d/java_home_env.sh >/dev/null

export JAVA_HOME=$(update-alternatives --query java | grep Value | cut -d" " -f2 | sed 's!\(\/.*\)jre\(.*\)!\1!g')
export JDK_HOME=${JAVA_HOME}
export JRE_HOME=${JDK_HOME}/jre/

EOF

As your shell might not be set as interactive by default, you may want to do this also:
2.b

cat <<'EOF' | sudo tee -a /etc/bash.bashrc >/dev/null
if [ -d /etc/profile.d ]; then
  for i in /etc/profile.d/*.sh; do
    if [ -r $i ]; then
      . $i
    fi
  done
  unset i
fi
EOF

PS: There should be no need to update the $PATH, as update-alternatives takes care of the link to /usr/bin/.
More on: https://manpages.ubuntu.com/manpages/trusty/man8/update-alternatives.8.html

Intern

When I use option 1. above after installing "openjdk-11-jdk-headless" I get JAVA_HOME and JDK_HOME both equal to "/usr/lib/jvm/java-11-openjdk-amd64/bin/java", which I assume it not correct. At least Maven/mvn says "The JAVA_HOME environment variable is not defined correctly. NB: JAVA_HOME should point to a JDK not a JRE" j – Bordello

Answer 8

To set up system wide scope you need to use the

/etc/environment file sudo gedit /etc/environment

is the location where you can define any environment variable. It can be visible in the whole system scope. After variable is defined system need to be restarted.

EXAMPLE :

sudo gedit /etc/environment

Add like following :

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
JAVA_HOME="/opt/jdk1.6.0_45/"

Here is the site you can find more : http://peesquare.com/blogs/environment-variable-setup-on-ubuntu/

Contradict

If you update any entries do reload using source /etc/environment command – Gasconade

Or logout to activate the new variable automatically (see this question) – Frosty

Answer 9

• Open terminal (Ctrl+Alt+t)

• Type

  sudo gedit .bashrc 
  

• Enter password of ubuntu user
• Go to last line of the file

• Type below code in new line

  export JAVA_HOME=enter_java_path_here
  export PATH=$JAVA_HOME/bin:$PATH
  eg: export JAVA_HOME=/home/pranav/jdk1.8.0_131
      export PATH=$JAVA_HOME/bin:$PATH
  

• Save the file

• Type

  source ~/.bashrc
  

  in terminal

• Done

Rik

Answer 10

Create/Open ~/.bashrc file $vim ~/.bashrc Add JAVA_HOME and PATH as referring to your JDK path

export JAVA_HOME=/usr/java/<your version of java>
export PATH=${PATH}:${JAVA_HOME}/bin

Save file

Now type java -version it should display what you set in .bashrc file.

This will persist over sessions as well.

Example :

Hydrotaxis

This works perfectly. I was adding "" initially and that does not work on Ubuntu. – Shoran

Answer 11

It should put java in your path, probably in /usr/bin/java. The easiest way to find it is to open a term and type which java.

Symphonize

Answer 12

1. Update bashrc file to add JAVA_HOME

   sudo nano ~/.bashrc

2. Add JAVA_HOME to bashrc file.

   export JAVA_HOME=/usr/java/<your version of java>
export PATH=${PATH}:${JAVA_HOME}/bin

3. Ensure Java is accessible

   java -version

4. In Case of Manual installation of JDK, If you got an error as shown below

   Error occurred during initialization of VM
   java/lang/NoClassDefFoundError: java/lang/Object
   

5. Execute the following command in your JAVA_HOME/lib directory:

   unpack200 -r -v -l "" tools.pack tools.jar

6. Execute the following commands in your JAVA_HOME/jre/lib

   ../../bin/unpack200 rt.pack rt.jar ../../bin/unpack200 jsse.pack jsse.rar ../../bin/unpack200 charsets.pack charsets.jar

7. Ensure Java is accessible

   java -version

Ridgway

Answer 13

Once I've installed the openjdk version of the Java Development Kit on an Ubuntu machine, I use this procedure to create a JAVA_HOME environment variable that doesn't need to be changed after every version upgrade of the openjdk installation.

Firstly, I issue a command to discover the directory in which the java executables are located for this java installation.

echo $(readlink -e `which java` | xargs -0 dirname)

If I'm happy with the output from that, everything else can be derived from it.

Configuring the JAVA_HOME and PATH environment variables

Rather than adding more and more configurations to the ~/.bashrc file I've found it a cleaner practice to create a separate small file that ~/.bashrc can "include" when it runs.

Let's call that file ~/.java_env_vars (but you could name it whatever you wish).

Add an "include condition" to the ~/.bashrc file

Open ~/.bashrc in any text editor and these lines to the end of the file:

# include the java environment configuration file here (if it exists)
if [ -f "$HOME/.java_env_vars" ]; then
    . $HOME/.java_env_vars
fi

Create the Java environment variable configuration file

Open any text editor, create the Java environment configuration file ~/.java_env_vars and add this content to it:

#1.  set a java_bin variable to the directory containing the actual Java executables.
java_bin=$(readlink -e `which java` | xargs -0 dirname)

#2. append "$java_bin" to the PATH environment variable
export PATH=$PATH:"$java_bin"

#3. assign the directory of the current Java installation to the JAVA_HOME environment variable.
export JAVA_HOME=$(dirname "$java_bin")

NOTE: exporting the PATH and JAVA_HOME variables just ensures that they're always available wherever they're needed.

Source your ~/.bashrc file (so that the changes you made to it are reflected) using the following command:

source ~/.bashrc

Test the Java environment variable configuration

Open a new terminal console, and test the new Java environment variables by issuing this command:

echo "$PATH" && echo "$JAVA_HOME"

Output should be two lines, something like this:

/home/user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/usr/lib/jvm/java-11-openjdk-amd64/bin
/usr/lib/jvm/java-11-openjdk-amd64

Pride

Answer 14

I have a Linux Lite 3.8 (It bases on Ubuntu 16.04 LTS) and a path change in the following file (with root privileges) with restart has helped.

/etc/profile.d/jdk.sh

Indecision

Answer 15

Let me simplify:

1. download JDK from Oracle Website : Link

2. Extract it

3. Create a folder (jvm) in /usr/lib/ i.e /usr/lib/jvm

4. move the extracted folder from the jdk to /usr/lib/jvm/

*Note : use terminal, sudo, mv command i.e. sudo mv

5. Create a .sh file at /etc/profile.d/ eg: /etc/profile.d/myenvvar.sh

6. In the .sh file type

export JAVA_HOME=/usr/lib/jvm/jdk1.7.0

export PATH=$PATH:$JAVA_HOME/bin

*Note : use terminal, gedit and sudo eg: sudo gedit myenvvar.sh

7. Turn Off the Computer, after all these steps and Restart it

8. Open Terminal , and type

java -version

9. Check the output , then type

echo $JAVA_HOME

Jocular

My JAVA_HOME was set in /etc/profile.d/maven.sh. Thank you. – Korfonta

Answer 16

Step1:

sudo gedit ~/.bash_profile

Step2:

JAVA_HOME=/home/user/tool/jdk-8u201-linux-x64/jdk1.8.0_201
PATH=$PATH:$HOME/bin:$JAVA_HOME/bin
export JAVA_HOME
export JRE_HOME
export PATH

Step3:

source ~/.bash_profile

Jerold

Answer 17

open jdk once installed resides generally in your /usr/lib/java-6-openjdk

As usual you would need to set the JAVA_HOME, classpath and Path.

In ubuntu 11.04 there is a environment file available in /etc where you need to set all the three paths. And then you would need to restart your system for the changes to take effect..

Here is a site to help you around http://aliolci.blogspot.com/2011/05/ubuntu-1104-set-new-environment.html

Merger

Answer 18

All you have to do now is to set the “JAVA_HOME” and “PATH” environment variables and then you are done. Enter the following commands to set your environment variables. Make sure that your environment variables point to a valid installation of JDK on your machine. For Ubuntu 18.04, the path is /usr/lib/jvm/java-8-openjdk-amd64/

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64

To check whether your JAVA_HOME path has been successfully saved, enter the following command to check.

echo $JAVA_HOME

Biweekly

This works only for terminal session and nowhere else – Stalk

Answer 19

Open file /etc/environment with a text editor Add the line JAVA_HOME="[path to your java]" Save and close then run source /etc/environment

Blub

Answer 20

Set java version from the list of installed. For see the list of the installed version run following command:

update-java-alternatives --list

Then set your java version according to the following command:

sudo update-java-alternatives --set /usr/lib/jvm/java-1.8.0-openjdk-amd64

Sublime

Answer 21

1. Once JDK installed set the JAVA_HOME in environment

   sudo nano /etc/environment and add the line JAVA_HOME="/usr/lib/jvm/jdk-11.0.1/"

2. Add the configuration in .bashrc

sudo nano ~/.bashrc and add following lines

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

3. refresh the new configuration with source ~/.bashrc
4. enter the command java -version and you can see the version installed on your machine

Jobye

Answer 22

First, check whether env var exists or not

echo $JAVA_HOME

if an env var exists with that name then the above command will return the env var Path. if it's return nothing then copy the env path first then execute below command. such as my java env path is /usr/lib/jvm/java-11-openjdk-amd64

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64

Ramonaramonda

Answer 23

Installation of Oracle Java:

1. Download the tarball (.tar file) from Oracle website
2. unzip it by sudo tar -xvpzf fileName -C /installation_folder_name
3. change the files permission and ownership
4. add the following two lines in /etc/profile

export JAVA_HOME=/home/abu/Java/jdk1.8.0_45/
export PATH=$JAVA_HOME/bin:$PATH

5. restart the machine and check by java -version and javac -version

Melton

Answer 24

You can install the default Ubuntu(17.10) java from apt:

sudo apt install openjdk-8-jdk-headless 

And it will set the PATH for you, if instead you need to install specific version of Java you can follow this YouTube

Ehtelehud

Answer 25

Use the following lines to set the path variables in the /etc/environment

echo export JAVA_HOME=/path/to/java | sudo tee -a /etc/environment
echo export JRE_HOME=/path/to/jre  | sudo tee -a /etc/environment

It should work.

Note:

You should reboot the system for changes to take effect.

Insanitary

Answer 26

I installed java 11 in my Ubuntu 20.04. Setting up a JAVA_HOME for the same.

enter the this command to find out your ubuntu version --

swapnil@swapnil-vm:~$ lsb_release -d
Description:    Ubuntu 20.04.3 LTS

enter this command to find out the location of your jvm --

swapnil@swapnil-vm:~$ whereis jvm
jvm: /usr/lib/jvm

open .bashrc in any editor of your choice --

nano .bashrc

add the following lines --

## setting JAVA_HOME
JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export JAVA_HOME

PATH=$PATH:$JAVA_HOME/bin
export PATH

now you are good to go!!
open a new terminal and enter the command --

ehco $JAVA_HOME

Romeoromeon