Correct way to check Java version from BASH script

Question

How can I check whether Java is available (in the PATH or via JAVA_HOME) from a bash script and make sure the version is at least 1.5?

Java 5 has been end-of-life for quite a long time. Java 6 will be end-of-life very soon. You should be moving to Java 6 as a priority, and to 7 as soon as you can. — kittylyst, Sep 07 '11 at 13:38
[What have you tried?](http://mattgemmell.com/2008/12/08/what-have-you-tried) — Brian Roach, Sep 07 '11 at 13:38
@Brian: Nothing; My hope is that someone has a "bash search path function" handy. — Aaron Digulla, Sep 07 '11 at 14:16
@kittylyst: This is a minimal requirement. My software doesn't need Java 6 features, so there is no point forcing users for something better. But thanks for pointing it out anyway. — Aaron Digulla, Sep 07 '11 at 14:20

score 101 · Accepted Answer · answered Sep 07 '11 at 14:24

101

Perhaps something like:

if type -p java; then
    echo found java executable in PATH
    _java=java
elif [[ -n "$JAVA_HOME" ]] && [[ -x "$JAVA_HOME/bin/java" ]];  then
    echo found java executable in JAVA_HOME     
    _java="$JAVA_HOME/bin/java"
else
    echo "no java"
fi

if [[ "$_java" ]]; then
    version=$("$_java" -version 2>&1 | awk -F '"' '/version/ {print $2}')
    echo version "$version"
    if [[ "$version" > "1.5" ]]; then
        echo version is more than 1.5
    else         
        echo version is less than 1.5
    fi
fi

answered Sep 07 '11 at 14:24

glenn jackman

238,783
38
220
352

Excellent. I was missing the `type` builtin. – Aaron Digulla Sep 07 '11 at 14:31
2

Ug sorry cant get comments to format. This fails when Java version is 1.10. This is because string comapre is not a number compare. Also the answer is wrong when version is "1.5" Though I guess that would be "1.5.0" so I guess its okay. – Andrew Jan 23 '14 at 20:53
1

good point. you could do something like: `IFS=. read major minor extra <<<"$version"; if (( major == 1 && minor > 5 )); ...` -- would have to check for invalid octal numbers like "08". – glenn jackman Jan 23 '14 at 21:42
3

the "`type -p java`" won't work in "sh"; so, for portability, use `#!/bin/bash` in the script, rather than `#!/bin/sh` (though, it's possible that `/bin/sh` isn't actually bourne shell, but rather a backward compatible variant) – michael Sep 12 '14 at 05:45
4

For comparing versions, I suggest : `version1=$(echo "$version" | awk -F. '{printf("%03d%03d",$1,$2);}')` which will get you major and minor aligned with 3 digit for each, and then compare with `if [ $version1 -ge 001008 ] ; then` – khaemuaset Jan 18 '16 at 11:13
Combining Glenn's original post with his comment above, I did the following to check for Java <=1.7 (in this case related to setting TLS defaults: `IFS=. read major minor extra <<<$(java -version 2>&1 | awk -F '"' '/version/ {print $2}'); if [ $major -lt 1 -o $major -eq 1 -a $minor -le 7 ]; then JVM_EXTRA_OPTS="-Dhttps.protocols=TLSv1.2,TLSv1.1,TLSv1"; fi` – Ben XO Jun 03 '20 at 18:17
Boo, hiss for showing a string comparison instead of a version comparison. – Charles Duffy Aug 31 '22 at 15:39

score 53 · Answer 2 · edited Jun 13 '21 at 06:29

53

You can obtain java version via:

JAVA_VER=$(java -version 2>&1 | sed -n ';s/.* version "\(.*\)\.\(.*\)\..*".*/\1\2/p;')

it will give you 16 for java like 1.6.0_13, 15 for version like 1.5.0_17 and 110 for openjdk 11.0.6 2020-01-14 LTS.

So you can easily compare it in shell:

[ "$JAVA_VER" -ge 15 ] && echo "ok, java is 1.5 or newer" || echo "it's too old..."

UPDATE: This code should work fine with openjdk and JAVA_TOOL_OPTIONS as mentioned in comments.

edited Jun 13 '21 at 06:29

Venkateswara Rao

5,242
1
18
13

answered Sep 07 '11 at 13:58

Michał Šrajer

30,364
7
62
85

10

The result of 'java -version' with OpenJDK 8 is slightly different, "java" is replaced by "openjdk" in the output. This expression works with both cases: `sed 's/.*version "$.*$\.$.*$\..*"/\1\2/; 1q'` – Emmanuel Bourg Aug 08 '14 at 22:30
1

If JAVA_TOOL_OPTIONS is set the output is again slightly different, the java version is not on the first line. eg: Picked up JAVA_TOOL_OPTIONS: -agentlib:hprof java version "1.7.0_60" Java(TM) SE Runtime Environment (build 1.7.0_60-b19) Java HotSpot(TM) 64-Bit Server VM (build 24.60-b09, mixed mode) Dumping Java heap ... allocation sites ... done – CodeBuddy Oct 16 '14 at 07:32
EmmanuelBourg and codebuddy thanks. I updated code to fix issues you found. – Michał Šrajer Mar 02 '17 at 10:51
4

This doesn't work correctly anymore since java 9, and fails spectacularly since java 10 – Michael Borgwardt Oct 17 '18 at 11:23
Some tweak to this as below should work after Java 9 as well... JAVA_VER=$(java -version 2>&1 | sed -n ';s/.* version "$.*$\.$.*$\..*"/\1\2/p;') – Venkateswara Rao Jun 13 '21 at 06:10

dvlcube · Answer 3 · 2020-06-16T19:50:22.957

The answers above work correctly only for specific Java versions (usually for the ones before Java 9 or for the ones after Java 8.

I wrote a simple one liner that will return an integer for Java versions 6 through 11 (and possibly all future versions, until they change it again!).

It basically drops the "1." at the beginning of the version number, if it exists, and then considers only the first number before the next ".".

java -version 2>&1 | head -1 | cut -d'"' -f2 | sed '/^1\./s///' | cut -d'.' -f1

jmj · Answer 4 · 2016-02-29T01:00:36.360

16

You can issue java -version and read & parse the output

java -version 2>&1 >/dev/null | grep 'java version' | awk '{print $3}'

edited Feb 29 '16 at 01:00

answered Sep 07 '11 at 13:36

jmj

237,923
42
401
438

This is very close to what I want. Do you know of a version which also searches `$PATH` before it calls `locate` (which isn't always available)? – Aaron Digulla Sep 07 '11 at 14:18
both links dont work and I checked my internet twice :-) – Ravi Feb 28 '16 at 21:07
@Ravi, right I will edit those links, you could use `java -version 2>&1 >/dev/null | grep 'java version' | awk '{print $3}'` by the time – jmj Feb 29 '16 at 01:00
2

If interested in the numerical part only and for further usage in path variables, you may use something like `java -version 2>&1 | head -1 | cut -d '"' -f 2` – U880D Mar 15 '18 at 10:36

score 9 · Answer 5 · answered Feb 20 '20 at 13:49

9

You could also compare the jdk class version number with javap:

javap -verbose java.lang.String | grep "major version" | cut -d " " -f5

If its java 8, this will print 52, and 55 for java 11. With this you can make a simple comparison and you don't have to deal with the version string parsing.

answered Feb 20 '20 at 13:49

zhujik

6,514
2
36
43

This is a nice hack if you just want to know the major version. Sometimes, you'd like to check that a certain patchlevel is installed. – Aaron Digulla Mar 27 '20 at 18:13
Amazing, this is bullet proof !! – Carlos Saltos Oct 06 '20 at 07:44
Simple and easy for major version check – enridaga Oct 08 '21 at 08:02

score 8 · Answer 6 · answered Feb 15 '18 at 23:33

I wrote a bash function that should work for JDK 9 and JDK 10.

#!/bin/bash

# returns the JDK version.
# 8 for 1.8.0_nn, 9 for 9-ea etc, and "no_java" for undetected
jdk_version() {
  local result
  local java_cmd
  if [[ -n $(type -p java) ]]
  then
    java_cmd=java
  elif [[ (-n "$JAVA_HOME") && (-x "$JAVA_HOME/bin/java") ]]
  then
    java_cmd="$JAVA_HOME/bin/java"
  fi
  local IFS=$'\n'
  # remove \r for Cygwin
  local lines=$("$java_cmd" -Xms32M -Xmx32M -version 2>&1 | tr '\r' '\n')
  if [[ -z $java_cmd ]]
  then
    result=no_java
  else
    for line in $lines; do
      if [[ (-z $result) && ($line = *"version \""*) ]]
      then
        local ver=$(echo $line | sed -e 's/.*version "\(.*\)"\(.*\)/\1/; 1q')
        # on macOS, sed doesn't support '?'
        if [[ $ver = "1."* ]]
        then
          result=$(echo $ver | sed -e 's/1\.\([0-9]*\)\(.*\)/\1/; 1q')
        else
          result=$(echo $ver | sed -e 's/\([0-9]*\)\(.*\)/\1/; 1q')
        fi
      fi
    done
  fi
  echo "$result"
}

v="$(jdk_version)"
echo $v

This returns 8 for Java 8 ("1.8.0_151" etc), and 9 for Java 9 ("9-Debian" etc), which should make it easier to do the further comparison.

Seb T · Answer 7 · 2021-06-21T21:07:01.237

Determining the Java version only using grep with Perl-style regex can be done like this:

java -version 2>&1 | grep -oP 'version "?(1\.)?\K\d+'

This will print the major version for Java 9 or higher and the minor version for versions lower than 9, for example 8 for Java 1.8 and 11 for Java 11.0.4.

It can be used like this:

JAVA_MAJOR_VERSION=$(java -version 2>&1 | grep -oP 'version "?(1\.)?\K\d+' || true)
if [[ $JAVA_MAJOR_VERSION -lt 8 ]]; then
  echo "Java 8 or higher is required!"
  exit 1
fi

The || true was added to prevent the script from aborting in case Java is not installed and the Shell option set -e was enabled.

score 4 · Answer 8 · edited Nov 03 '16 at 17:49

4

A combination of different answers:

JAVA_VER=$(java -version 2>&1 | grep -i version | sed 's/.*version ".*\.\(.*\)\..*"/\1/; 1q')

Returns 7 for Java 7 and 8 for Java 8
Works with OpenJDK and with Oracle JDK
Works even if the JAVA_TOOL_OPTIONS is set

edited Nov 03 '16 at 17:49

Guillaume Racicot

39,621
9
77
141

answered Nov 03 '16 at 17:17

Manu D.

357
3
8

4

for Java 10, this returns '0' for the version number – aenw Sep 21 '18 at 21:32
$ java -version 2>&1 | grep -i version | sed 's/.*version ".*\.$.*$\..*"/\1/; 1q' --> 0 for java version "9.0.1" – 18446744073709551615 Oct 08 '19 at 12:58
Indeed, answer below works better for java version > 9: https://stackoverflow.com/a/56243046/3193604 – Manu D. Oct 08 '20 at 08:55

score 3 · Answer 9 · edited Feb 10 '20 at 13:05

3

in TERMINAL

java -version |& grep 'version' |& awk -F\" '{ split($2,a,"."); print a[1]"."a[2]}'

in BASH

#!/bin/bash


echo `java -version 2>&1 | grep 'version' 2>&1 | awk -F\" '{ split($2,a,"."); print a[1]"."a[2]}'`
jver=`java -version 2>&1 | grep 'version' 2>&1 | awk -F\" '{ split($2,a,"."); print a[1]"."a[2]}'`

if [[ $jver == "1.8" ]]; then                
     echo $jver is java 8
else
     echo $jver is java 11
fi

Works in SUN and Linux

edited Feb 10 '20 at 13:05

Aaron Digulla

321,842
108
597
820

answered Feb 03 '20 at 09:35

David Ben David

31
5

Small improvements: Use `$(...)` instead of backticks. They are safer, support nesting, and easier to type on most keyboards/OSs. – Aaron Digulla Feb 10 '20 at 13:05

score 2 · Answer 10 · edited Jun 02 '16 at 14:48

2

The method I ended up using is:

# Work out the JAVA version we are working with:
JAVA_VER_MAJOR=""
JAVA_VER_MINOR=""
JAVA_VER_BUILD=""

# Based on: http://stackoverflow.com/a/32026447
for token in $(java -version 2>&1 | grep -i version)
do
    if [[ $token =~ \"([[:digit:]])\.([[:digit:]])\.(.*)\" ]]
    then
        JAVA_VER_MAJOR=${BASH_REMATCH[1]}
        JAVA_VER_MINOR=${BASH_REMATCH[2]}
        JAVA_VER_BUILD=${BASH_REMATCH[3]}
        break
    fi
done

It will work correctly even if JAVA_TOOL_OPTIONS is set to something due to filtering done by grep.

edited Jun 02 '16 at 14:48

Aaron Digulla

321,842
108
597
820

answered Jun 02 '16 at 13:56

Jinesh Choksi

988
6
6

Oneliner: `if [[ $(java -version 2>&1 >/dev/null | grep 'java version' | awk '{print $3}') =~ \"([0-9])\.([0-9])\.([0-9])_(.*)\" ]]; then echo ${BASH_REMATCH[2]}; fi` – neu242 Apr 20 '17 at 07:42

score 2 · Answer 11 · answered Dec 01 '20 at 15:30

Another way is: A file called release is located in $JAVA_HOME. On Java 15 (Debian) it has as content:

IMPLEMENTOR="Debian"
JAVA_VERSION="15.0.1"
JAVA_VERSION_DATE="2020-10-20"
MODULES="java.base java.compiler java.datatransfer java.xml java.prefs java.desktop java.instrument java.logging java.management java.security.sasl java.naming java.rmi java.management.rmi java.net.http java.scripting java.security.jgss java.transaction.xa java.sql java.sql.rowset java.xml.crypto java.se java.smartcardio jdk.accessibility jdk.internal.vm.ci jdk.management jdk.unsupported jdk.internal.vm.compiler jdk.aot jdk.internal.jvmstat jdk.attach jdk.charsets jdk.compiler jdk.crypto.ec jdk.crypto.cryptoki jdk.dynalink jdk.internal.ed jdk.editpad jdk.hotspot.agent jdk.httpserver jdk.incubator.foreign jdk.internal.opt jdk.jdeps jdk.jlink jdk.incubator.jpackage jdk.internal.le jdk.internal.vm.compiler.management jdk.jartool jdk.javadoc jdk.jcmd jdk.management.agent jdk.jconsole jdk.jdwp.agent jdk.jdi jdk.jfr jdk.jshell jdk.jsobject jdk.jstatd jdk.localedata jdk.management.jfr jdk.naming.dns jdk.naming.rmi jdk.net jdk.nio.mapmode jdk.sctp jdk.security.auth jdk.security.jgss jdk.unsupported.desktop jdk.xml.dom jdk.zipfs"
OS_ARCH="x86_64"
OS_NAME="Linux"
SOURCE=""

So you see JAVA_VERSION, which contains the version number.

For example,

major=$(echo $JAVA_VERSION | cut -d. -f1)

sets major to the value 15 (=Major version number), which you can use further.

It's a really simple solution.

Interesting. I found the file in several JDKs (Oracle and OpenJDK). I don't think it will exist in J9 or the Amazon JVM. Plus you need to figure out the Java installation folder if `$JAVA_HOME` isn't defined. — Aaron Digulla, Dec 16 '20 at 15:11

Léa Gris · Answer 12 · 2022-12-12T12:28:19.143

2

Getting java version string, using Bash's built-in parsing capabilities:

#!/usr/bin/env bash

java_cmd=${1:-java}

# Captures version string between double-quotes
IFS='"' read -r _ java_version_string _ < <("${java_cmd}" -version 2>&1)

# Splits version string at dots and (underscore for patch number)
IFS='._' read -r \
  java_version_major \
  java_version_minor \
  java_version_build \
  java_version_patch \
  <<<"$java_version_string"

# Debug demo output
declare -p java_version_major java_version_minor java_version_build \
  java_version_patch

Examples

System default Java 17:

declare -- java_version_major="17"
declare -- java_version_minor="0"
declare -- java_version_build="3"
declare -- java_version_patch=""

Specific Java 8 path provided as argument:

declare -- java_version_major="1"
declare -- java_version_minor="8"
declare -- java_version_build="0"
declare -- java_version_patch="352"

edited Dec 12 '22 at 12:28

answered Nov 16 '22 at 10:56

Léa Gris

17,497
4
32
41

I''m getting `-bash: java_version_major: command not found` for the line with the here string `<<<`. – Aaron Digulla Dec 12 '22 at 10:24
1

`IFS="." read java_version_major java_version_minor java_version_build java_version_patch <<< "$java_version_string"` works for me. – Aaron Digulla Dec 12 '22 at 10:25
1

@AaronDigulla I broke my answer with an unfortunate cut during an edit. It is now fixed. – Léa Gris Dec 12 '22 at 10:43

score 1 · Answer 13 · answered Jan 01 '19 at 12:25

I had a similar problem, I wanted to check which version of java was installed to perform two types of application launches. The following code has solved my problem

jdk_version() {
  local result
  local java_cmd
  if [[ -n $(type -p java) ]]
  then
    java_cmd=java
  elif [[ (-n "$JAVA_HOME") && (-x "$JAVA_HOME/bin/java") ]]
  then
    java_cmd="$JAVA_HOME/bin/java"
  fi
  local IFS=$'\n'
  # remove \r for Cygwin
  local lines=$("$java_cmd" -Xms32M -Xmx32M -version 2>&1 | tr '\r' '\n')
  if [[ -z $java_cmd ]]
  then
    result=no_java
  else
    for line in $lines; do
      if [[ (-z $result) && ($line = *"version \""*) ]]
      then
        local ver=$(echo $line | sed -e 's/.*version "\(.*\)"\(.*\)/\1/; 1q')
        # on macOS, sed doesn't support '?'
        if [[ $ver = "1."* ]]
        then
          result=$(echo $ver | sed -e 's/1\.\([0-9]*\)\(.*\)/\1/; 1q')
        else
          result=$(echo $ver | sed -e 's/\([0-9]*\)\(.*\)/\1/; 1q')
        fi
      fi
    done
  fi
  echo "$result"
}

_java="$(jdk_version)"
echo $_java

if [[ "$_java" > "$8" ]]; then
       echo version is more than 8

else
  echo version is less than 8

fi

source

I hope to be proved helpful

You should be able to replace the `sed` with BASH parameter expansion (https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html) using `${parameter/pattern/string}` — Aaron Digulla, Jan 25 '19 at 12:27
@AaronDigulla Thanks for the information, I will see the link and I update the answer — vincenzopalazzo, Jan 25 '19 at 16:29

score 1 · Answer 14 · answered Sep 21 '20 at 10:24

There is a nice portable bash function for this here: http://eed3si9n.com/detecting-java-version-bash

jdk_version() {
  local result
  local java_cmd
  if [[ -n $(type -p java) ]]
  then
    java_cmd=java
  elif [[ (-n "$JAVA_HOME") && (-x "$JAVA_HOME/bin/java") ]]
  then
    java_cmd="$JAVA_HOME/bin/java"
  fi
  local IFS=$'\n'
  # remove \r for Cygwin
  local lines=$("$java_cmd" -Xms32M -Xmx32M -version 2>&1 | tr '\r' '\n')
  if [[ -z $java_cmd ]]
  then
    result=no_java
  else
    for line in $lines; do
      if [[ (-z $result) && ($line = *"version \""*) ]]
      then
        local ver=$(echo $line | sed -e 's/.*version "\(.*\)"\(.*\)/\1/; 1q')
        # on macOS, sed doesn't support '?'
        if [[ $ver = "1."* ]]
        then
          result=$(echo $ver | sed -e 's/1\.\([0-9]*\)\(.*\)/\1/; 1q')
        else
          result=$(echo $ver | sed -e 's/\([0-9]*\)\(.*\)/\1/; 1q')
        fi
      fi
    done
  fi
  echo "$result"
}

score 0 · Answer 15 · answered Nov 26 '14 at 08:01

0

I know this is a very old thread but this will still be of help to others.

To know whether you're running Java 5, 6 or 7, firstly type java -version.

There will be a line in your output that looks similar to this: java version "1.7.0_55"

Then you use this table for converting the 'jargon' result to the version number.

1.7.0_55 is Java 7
1.6.0_75 is Java 6
1.5.0_65 is Java 5

Information taken from a page on the Oracle site
http://www.oracle.com/technetwork/java/javase/7u55-relnotes-2177812.html

answered Nov 26 '14 at 08:01

Richard

386
4
8

1

This doesn't work if you have anything other than those specific minor versions of Java, e.g. – David Moles Jan 23 '15 at 17:59
Well. I got this information from a page on the official Oracle site. I don't know it all and neither do I pretend to. If you know what other versions of Java there are then feel free to add a subcomment with these underneath this message. – Richard Jan 24 '15 at 18:31
1

1.5.0_anything is Java 5, 1.6.0_anything is Java 6, 1.7.0_anything is Java 7, 1.8.0_anything is Java 8. The minor versions change all the time (though I suppose there aren't ever going to be any new ones for Java 5 or 6). – David Moles Jan 26 '15 at 16:56
1

Also, there's no guarantee anyone will have the most recent minor version. – David Moles Jan 26 '15 at 16:56
That's fair enough. Why didn't you just say that in the first place? I had a feeling that 1.x... meant version x but I didn't want to make that assumption in case I was wrong. – Richard Jan 27 '15 at 09:15

score 0 · Answer 16 · answered Jun 18 '18 at 16:10

Using bashj, an extended bash version (https://sourceforge.net/projects/bashj/), you get a rather compact solution:

#!/usr/bin/bashj
echo System.getProperty("java.runtime.version")

The answer is provided by an integrated JVM (in ~0.017'' execution time for the script , and ~0.004'' for the call itself).

Paul Stoner · Answer 17 · 2021-07-20T16:13:06.140

0

I found the following works rather well. It is a combination of the answers from Michał Šrajer and jmj

version=$(java -version 2>&1 | sed -n ';s/.* version "$.*$\.$.*$\..*"/\1\2/p;' | awk '{ print $1 }').

I have openJDK 13 installed and without the awk command the first answer printed: 130 2020-01-14. Thus, adding awk '{ print $1 }' provides me with just the version.

edited Jul 20 '21 at 16:13

answered Jan 21 '21 at 14:43

Paul Stoner

1,359
21
44

Correct way to check Java version from BASH script

17 Answers17

Linked