Technical Note TN2110

Identifying Java on OS X

This Technical Note discusses the recommended ways to identify an OS X Java installation at runtime, as well as differentiating between the various Apple Java releases for OS X. It is targeted at developers who need to provide features or workarounds in their applications which are specific to the OS X platform, or to a particular Java release for OS X. End-user techniques for discovering installed versions of Java are not discussed.

Identifying OS X from Java Identifying a Java Version Identifying a OS X Version from Java Identifying an Apple Java Version mrj.version Java Version Strings Document Revision History

Identifying OS X from Java

Apple has made a Java SE runtime available for OS X, beginning with version 10.0. Any pure Java application should run great on OS X, but there are times when you may want to know which platform your application is running on. For example, to handle the About, Preferences, and Quit menu items your application can use the com.apple.eawt APIs, but it should only call those APIs on OS X. There are a number of ways to detect the current platform, but the easiest and most reliable way is to check the standard os.name System property:

Listing 1: Detecting OS X in Java code.

public static boolean isOSX() {
    String osName = System.getProperty("os.name");
    return osName.contains("OS X");
}

This is the preferred method for detecting an OS X system, because it uses a standard System property with a known value.

Back to Top

Identifying a Java Version

The next level of granularity to examine is which specific Java version your application is running under. For example, perhaps you want to use Java 1.5-specific APIs, but remain compatible with Java 1.4. There's nothing special about this on OS X: as on any other platform, you need to check the java.version System property:

Listing 2: Detecting a Major Java Version.

public static boolean isJava15OrBetter() {
    String javaVersion = System.getProperty("java.version");
    String[] fragments = javaVersion.split("\\.");

    // sanity check the "1." part of the version
    if (!fragments[0].equals("1")) return false;
    if (fragments.length < 2) return false;

    // check if Java 1.5.x or higher
    try {
        int minorVers = Integer.parseInt(fragments[1]);
        if (minorVers >= 5) return true;
    } catch (NumberFormatException e) {
        // was not an integer
    }

    return false;
}

Back to Top

Identifying a OS X Version from Java

Sometimes it is necessary to identify a major version of OS X to use a tool or a native library that requires a minimum version of OS X. The most reliable way to determine the OS X version is to use the os.version System property:

Listing 3: Detecting OS X in Java code.

public static boolean isSnowLeopardOrBetter() {
    String osName = System.getProperty("os.name");
    if (!osName.contains("OS X")) return false;

    // split the "10.x.y" version number
    String osVersion = System.getProperty("os.version");
    String[] fragments = osVersion.split("\\.");

    // sanity check the "10." part of the version
    if (!fragments[0].equals("10")) return false;
    if (fragments.length < 2) return false;

    // check if OS X 10.6(.y)
    try {
        int minorVers = Integer.parseInt(fragments[1]);
        if (minorVers >= 6) return true;
    } catch (NumberFormatException e) {
        // was not an integer
    }

    return false;
}

Back to Top

Identifying an Apple Java Version

While Apple does its best to make sure its Java releases track the latest Oracle releases, Apple software update schedules for OS X depend on many factors. Therefore, Apple does not necessarily ship a Java release for every Java version that Oracle does. It is also possible for Apple to release a Java update that fixes problems specific to Java on OS X before a new minor version appears from Oracle. In this scenario, there would would be two Java SE 6 releases for the same version of OS X with the same Java version number, and simply checking the java.version System property would not be adequate to determine which Apple release your application is running on.

Why should developers be concerned? If there is a problem specific to Java on OS X that is affecting your application, there are two likely solutions:

1. Your application prompts the user to update their Java to a version you know fixes the problem.

2. If the above is not an option, work around the problem in the release which exhibits it.

Either of these actions requires a way of specifically determining which Apple Java release your application is running on. There are a number of ways of doing this, but the recommended method is to analyze the java.runtime.version System property. Apple appends a release-specific version string to the end of this property that can be used to identify which Apple release you're using, regardless of the major/minor Java release numbers. Listing 2 illustrates how you might do this in your Java code.

Listing 4: Identifying a specific Apple Java release.

public static boolean isExactlyLeopardUpdate4() {
    if (!isOSX()) return false;

    String runtimeVersion = System.getProperty("java.runtime.version");
    if (!runtimeVersion.startsWith("1.5.0_")) return false;
    if (!runtimeVersion.endsWith("-304")) return false;
    return true;
}

Be sure to check against both the Java and Apple version substrings as in the example above. While highly unlikely, it's possible for more than one major Apple Java release (i.e. 1.3.x, 1.4.x, 1.5.x, 1.6.x) to have the same build strings at the end. Note that for additional robustness, this check is done in conjunction with the OS X check from Listing 1.

As with the previous code examples, this is the preferred method of determining which release of Java for OS X you're running, because it uses standard System properties.

mrj.version

Another System property provided by Apple, mrj.version, can be used to a similar end. However, it is a legacy system property dating back to the Classic Mac OS, and is not guaranteed to have a deterministic format through future releases. Furthermore, Apple is trying to stay as close to the standard Java functionality as possible. For these reasons, we recommend that you instead use the more standard os.name and java.runtime.version properties for Macintosh identification in all ongoing Java development, as outlined in this Technical Note.

Back to Top

Java Version Strings

In order to make use of the technique described above, you'll need to know the version strings for all Java releases on OS X. Tables 1 through 4 list the relevant System property values for all Java 1.3, 1.4, 5.0, and 6 releases, respectively, starting with Mac OS X 10.0. Java versions which shipped with a OS X release are listed under that corresponding version, with a dash under the "Java Release" column. Java releases which appeared as Software Updates and/or manual downloads are listed under the "Java Release" column, next to the version of OS X for which they were available.

Table 1 : J2SE 1.3 Releases on OS X

Table 2 : J2SE 1.4 Releases on OS X

Table 3 : J2SE 5.0 Releases on OS X

Table 4 : Java SE 6 Releases on OS X

Back to Top

Document Revision History