Ho bisogno di aggirare un bug Java in JDK 1.5 che è stato corretto in 1.6. Sto usando la seguente condizione:

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

Funzionerà con altre JVM? C'è un modo migliore per controllare questo?

Questi articoli sembrano suggerire che il controllo 1.5o il 1.6prefisso dovrebbero funzionare, poiché segue la convenzione di denominazione della versione corretta.

Articoli tecnici Sun

• Convenzione di denominazione delle stringhe della versione SDK / JRE J2SE
• Versione 1.5.0 o 5.0?
  • "J2SE mantiene anche il numero di versione 1.5.0 (o 1.5) in alcuni punti visibili solo agli sviluppatori o in cui il numero di versione viene analizzato dai programmi"
    • " java.versionproprietà di sistema"
• Versione 1.6.0 utilizzata dagli sviluppatori
  • "Java SE mantiene il numero di versione 1.6.0 (o 1.6) in alcuni punti visibili solo agli sviluppatori o in cui il numero di versione viene analizzato dai programmi."
    • " java.versionproprietà di sistema"

java.versionè una proprietà di sistema che esiste in ogni JVM. Ci sono due possibili formati per questo:

• Java 8 o abbassare: 1.6.0_23, 1.7.0, 1.7.0_80,1.8.0_211
• Java 9 o superiore: 9.0.1, 11.0.4, 12,12.0.1

Ecco un trucco per estrarre la versione principale: Se si tratta di una 1.x.y_zstringa di versione, estrarre il carattere nell'indice 2 della stringa. Se è una x.y.zstringa di versione, taglia la stringa al suo primo carattere punto, se esiste.

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);
}

Ora puoi controllare la versione molto più comodamente:

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

Che ne dici di ottenere la versione dalle meta informazioni del pacchetto:

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

Stampa qualcosa del tipo:

1.7.0_13

Runtime.version()

Da Java 9, è possibile utilizzare Runtime.version(), che restituisce un Runtime.Version:

Runtime.Version version = Runtime.version();

Il modo più semplice ( java.specification.version ):

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

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

o qualcosa del genere ( java.version ):

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

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

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

o se vuoi rompere tutto ( 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];

Solo una nota che in Java 9 e versioni successive, la convenzione di denominazione è diversa. System.getProperty("java.version")ritorna "9"piuttosto che "1.9".

Non funziona, è necessario --posvalutare il doppio:

    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;
}

Esempio per 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 :)
    }

Ecco l'implementazione in 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));
}

Se puoi avere dipendenza da apache utils puoi usare org.apache.commons.lang3.SystemUtils.

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

Non conosco un altro modo di controllare questo, ma questo: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/System.html#getProperties () "implica" java.version "è una proprietà di sistema standard, quindi mi aspetto che lavorare con altre JVM.

Ecco la risposta di @mvanle, convertita in Scala: scala> val Array(javaVerPrefix, javaVerMajor, javaVerMinor, _, _) = System.getProperty("java.runtime.version").split("\\.|_|-b") javaVerPrefix: String = 1 javaVerMajor: String = 8 javaVerMinor: String = 0