Je dois contourner un bogue Java dans JDK 1.5 qui a été corrigé dans 1.6. J'utilise la condition suivante:

if (System.getProperty("java.version").startsWith("1.5.")) {
    ...
} else {
    ...
}

Cela fonctionnera-t-il pour d'autres JVM? Y a-t-il une meilleure façon de vérifier cela?

Ces articles semblent suggérer que la vérification du préfixe 1.5ou du 1.6préfixe devrait fonctionner, car elle suit la convention de dénomination de version appropriée.

Articles techniques Sun

• Convention de dénomination des chaînes de version J2SE SDK / JRE
• Version 1.5.0 ou 5.0?
  • "J2SE conserve également le numéro de version 1.5.0 (ou 1.5) à certains endroits qui ne sont visibles que par les développeurs, ou là où le numéro de version est analysé par les programmes"
    • " java.versionpropriété système"
• Version 1.6.0 utilisée par les développeurs
  • "Java SE conserve le numéro de version 1.6.0 (ou 1.6) à certains endroits qui ne sont visibles que par les développeurs, ou là où le numéro de version est analysé par les programmes."
    • " java.versionpropriété système"

java.versionest une propriété système qui existe dans chaque JVM. Il existe deux formats possibles pour cela:

• Java 8 ou moins: 1.6.0_23, 1.7.0, 1.7.0_80,1.8.0_211
• Java 9 ou supérieur: 9.0.1, 11.0.4, 12,12.0.1

Voici une astuce pour extraire la version majeure: S'il s'agit d'une 1.x.y_zchaîne de version, extrayez le caractère à l'index 2 de la chaîne. S'il s'agit d'une x.y.zchaîne de version, coupez la chaîne à son premier caractère de point, s'il en existe un.

private static int getVersion() {
    String version = System.getProperty("java.version");
    if(version.startsWith("1.")) {
        version = version.substring(2, 3);
    } else {
        int dot = version.indexOf(".");
        if(dot != -1) { version = version.substring(0, dot); }
    } return Integer.parseInt(version);
}

Vous pouvez maintenant vérifier la version beaucoup plus confortablement:

if(getVersion() < 6) {
    // ...
}

Qu'en est-il d'obtenir la version à partir des méta-infos du package:

String version = Runtime.class.getPackage().getImplementationVersion();

Imprime quelque chose comme:

1.7.0_13

Runtime.version()

Depuis Java 9, vous pouvez utiliser Runtime.version(), qui renvoie un Runtime.Version:

Runtime.Version version = Runtime.version();

Le moyen le plus simple ( java.specification.version ):

double version = Double.parseDouble(System.getProperty("java.specification.version"));

if (version == 1.5) {
    // 1.5 specific code
} else {
    // ...
}

ou quelque chose comme ( java.version ):

String[] javaVersionElements = System.getProperty("java.version").split("\\.");

int major = Integer.parseInt(javaVersionElements[1]);

if (major == 5) {
    // 1.5 specific code
} else {
    // ...
}

ou si vous voulez tout casser ( java.runtime.version ):

String discard, major, minor, update, build;

String[] javaVersionElements = System.getProperty("java.runtime.version").split("\\.|_|-b");

discard = javaVersionElements[0];
major   = javaVersionElements[1];
minor   = javaVersionElements[2];
update  = javaVersionElements[3];
build   = javaVersionElements[4];

Juste une note que dans Java 9 et plus, la convention de dénomination est différente. System.getProperty("java.version")renvoie "9"plutôt que "1.9".

Ne fonctionne pas, besoin --posd'évaluer le double:

    String version = System.getProperty("java.version");
    System.out.println("version:" + version);
    int pos = 0, count = 0;
    for (; pos < version.length() && count < 2; pos++) {
        if (version.charAt(pos) == '.') {
            count++;
        }
    }

    --pos; //EVALUATE double

    double dversion = Double.parseDouble(version.substring(0, pos));
    System.out.println("dversion:" + dversion);
    return dversion;
}

Exemple pour Apache Commons Lang:

import org.apache.commons.lang.SystemUtils;

    Float version = SystemUtils.JAVA_VERSION_FLOAT;

    if (version < 1.4f) { 
        // legacy
    } else if (SystemUtils.IS_JAVA_1_5) {
        // 1.5 specific code
    } else if (SystemUtils.isJavaVersionAtLeast(1.6f)) {
        // 1.6 compatible code
    } else {
        // dodgy clause to catch 1.4 :)
    }

Voici l'implémentation dans JOSM :

/**
 * Returns the Java version as an int value.
 * @return the Java version as an int value (8, 9, etc.)
 * @since 12130
 */
public static int getJavaVersion() {
    String version = System.getProperty("java.version");
    if (version.startsWith("1.")) {
        version = version.substring(2);
    }
    // Allow these formats:
    // 1.8.0_72-ea
    // 9-ea
    // 9
    // 9.0.1
    int dotPos = version.indexOf('.');
    int dashPos = version.indexOf('-');
    return Integer.parseInt(version.substring(0,
            dotPos > -1 ? dotPos : dashPos > -1 ? dashPos : 1));
}

Si vous pouvez avoir une dépendance aux utils apache, vous pouvez utiliser org.apache.commons.lang3.SystemUtils.

    System.out.println("Is Java version at least 1.8: " + SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8));

Je ne connais pas d'autre moyen de vérifier cela, mais ceci: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/System.html#getProperties () "implique que" java.version "est une propriété système standard donc je m'attendrais à ce qu'il travailler avec d’autres JVM.

Voici la réponse de @mvanle, converti en Scala: scala> val Array(javaVerPrefix, javaVerMajor, javaVerMinor, _, _) = System.getProperty("java.runtime.version").split("\\.|_|-b") javaVerPrefix: String = 1 javaVerMajor: String = 8 javaVerMinor: String = 0