Comment est-ce que je détermine programmatically le système d'exploitation en Java?

Comme indiqué dans d'autres réponses, Système.getProperty fournit les données brutes. Cependant, le Apache Commons Lang component fournit un wrapper pour java.lang.Système avec des propriétés pratiques comme SystemUtils.IS_OS_WINDOWS , un peu comme le Swingx OS util mentionné ci-dessus.

Oct. 2008:

je recommande de le mettre en cache dans une variable statique:

public static final class OsUtils
{
   private static String OS = null;
   public static String getOsName()
   {
      if(OS == null) { OS = System.getProperty("os.name"); }
      return OS;
   }
   public static boolean isWindows()
   {
      return getOsName().startsWith("Windows");
   }

   public static boolean isUnix() // and so on
}

de cette façon, chaque fois que vous demandez L'Os, vous ne récupérez pas la propriété plus d'une fois dans la vie de votre demande.

---

février 2016: 7+ ans plus tard:

il y a un bug avec Windows 10 (qui n'existait pas au moment de la réponse originale).

Voir" Java " os.nom " pour Windows 10? "

certains des liens dans les réponses ci-dessus semblent être brisé. J'ai ajouté des pointeurs vers le code source courant dans le code ci-dessous et j'offre une approche pour gérer le contrôle avec un enum comme réponse afin qu'une instruction switch puisse être utilisée lors de l'évaluation du résultat:

OsCheck.OSType ostype=OsCheck.getOperatingSystemType();
switch (ostype) {
    case Windows: break;
    case MacOS: break;
    case Linux: break;
    case Other: break;
}

la classe helper est:

/**
 * helper class to check the operating system this Java VM runs in
 *
 * please keep the notes below as a pseudo-license
 *
 * /q/how-do-i-programmatically-determine-operating-system-in-java-47907/"os.name", "generic").toLowerCase(Locale.ENGLISH);
      if ((OS.indexOf("mac") >= 0) || (OS.indexOf("darwin") >= 0)) {
        detectedOS = OSType.MacOS;
      } else if (OS.indexOf("win") >= 0) {
        detectedOS = OSType.Windows;
      } else if (OS.indexOf("nux") >= 0) {
        detectedOS = OSType.Linux;
      } else {
        detectedOS = OSType.Other;
      }
    }
    return detectedOS;
  }
}

les classes JavaFX suivantes ont des méthodes statiques pour déterminer L'OS actuel (isWindows(),isLinux()...):

• com.soleil.javafx.PlatformUtil
• com.soleil.Média.jfxmediaimpl.HostUtils
• com.soleil.javafx.util.Utils

exemple:

if (PlatformUtil.isWindows()){
           ...
}

si vous êtes intéressé par la façon dont un projet open source fait des choses comme ça, vous pouvez consulter la classe Terracotta (Os.java) qui gère cette Camelote ici:

• http://svn.terracotta.org/svn/tc/dso/trunk/code/base/common/src/com/tc/util/runtime/
• http://svn.terracotta.org/svn/tc/dso/tags/2.6.4/code/base/common/src/com/tc/util/runtime /

et vous pouvez voir une classe similaire pour gérer les versions JVM (Vm.java et VmVersion.java) ici:

• http://svn.terracotta.org/svn/tc/dso/trunk/common/src/main/java/com/tc/util/runtime /

    private static String OS = System.getProperty("os.name").toLowerCase();

    public static void detectOS() {
        if (isWindows()) {

        } else if (isMac()) {

        } else if (isUnix()) {

        } else {

        }
    }

    private static boolean isWindows() {
        return (OS.indexOf("win") >= 0);
    }

    private static boolean isMac() {
        return (OS.indexOf("mac") >= 0);
    }

    private static boolean isUnix() {
        return (OS.indexOf("nux") >= 0);
    }

tiré de ce projet https://github.com/RishiGupta12/serial-communication-manager

String osName = System.getProperty("os.name");
String osNameMatch = osName.toLowerCase();
if(osNameMatch.contains("linux")) {
    osType = OS_LINUX;
}else if(osNameMatch.contains("windows")) {
    osType = OS_WINDOWS;
}else if(osNameMatch.contains("solaris") || osNameMatch.contains("sunos")) {
    osType = OS_SOLARIS;
}else if(osNameMatch.contains("mac os") || osNameMatch.contains("macos") || osNameMatch.contains("darwin")) {
    osType = OS_MAC_OS_X;
}else {
}

disons que vous avez une classe Util pour de telles fonctions Utilitaires. Ensuite, créez des enum publics pour chaque type de système d'exploitation.

public class Util {     
        public enum OS {
            WINDOWS, LINUX, MAC, SOLARIS
        };// Operating systems.

    private static OS os = null;

    public static OS getOS() {
        if (os == null) {
            String operSys = System.getProperty("os.name").toLowerCase();
            if (operSys.contains("win")) {
                os = OS.WINDOWS;
            } else if (operSys.contains("nix") || operSys.contains("nux")
                    || operSys.contains("aix")) {
                os = OS.LINUX;
            } else if (operSys.contains("mac")) {
                os = OS.MAC;
            } else if (operSys.contains("sunos")) {
                os = OS.SOLARIS;
            }
        }
        return os;
    }
}

ensuite, vous pouvez facilement invoquer la classe de n'importe quelle classe comme suit,(P.S. puisque la variable d'os que nous avons déclarée statique, il faudra du temps une seule fois pour identifier le type de système, puis il peut être utilisé jusqu'à ce que votre application s'arrête. )

            switch (Util.getOS()) {
            case WINDOWS:
                //do windows stuff
                break;
            case LINUX:

et ainsi de suite...

je trouve que le OS Utils de Swingx fait le travail.

Essayez,simple et facile

System.getProperty("os.name");
System.getProperty("os.version");
System.getProperty("os.arch");

ci-dessous code montre les valeurs que vous pouvez obtenir à partir de L'API du système, tout ce que vous pouvez obtenir à travers cette API.

public class App {
    public static void main( String[] args ) {
        //Operating system name
        System.out.println(System.getProperty("os.name"));

        //Operating system version
        System.out.println(System.getProperty("os.version"));

        //Path separator character used in java.class.path
        System.out.println(System.getProperty("path.separator"));

        //User working directory
        System.out.println(System.getProperty("user.dir"));

        //User home directory
        System.out.println(System.getProperty("user.home"));

        //User account name
        System.out.println(System.getProperty("user.name"));

        //Operating system architecture
        System.out.println(System.getProperty("os.arch"));

        //Sequence used by operating system to separate lines in text files
        System.out.println(System.getProperty("line.separator"));

        System.out.println(System.getProperty("java.version")); //JRE version number

        System.out.println(System.getProperty("java.vendor.url")); //JRE vendor URL

        System.out.println(System.getProperty("java.vendor")); //JRE vendor name

        System.out.println(System.getProperty("java.home")); //Installation directory for Java Runtime Environment (JRE)

        System.out.println(System.getProperty("java.class.path"));

        System.out.println(System.getProperty("file.separator"));
    }
}

réponses: -

Windows 7
6.1
;
C:\Users\user\Documents\workspace-eclipse\JavaExample
C:\Users\user
user
amd64


1.7.0_71
http://java.oracle.com/
Oracle Corporation
C:\Program Files\Java\jre7
C:\Users\user\Documents\workspace-Eclipse\JavaExample\target\classes
\

String osName = System.getProperty("os.name");
System.out.println("Operating system " + osName);

J'ai aimé la réponse de Wolfgang, juste parce que je crois que les choses comme ça devraient être consts...

donc je l'ai reformulé un peu pour moi-même, et j'ai pensé à le partager:)

/**
 * types of Operating Systems
 *
 * please keep the note below as a pseudo-license
 *
 * helper class to check the operating system this Java VM runs in
 * /q/how-do-i-programmatically-determine-operating-system-in-java-47907/"mac", "darwin"),
    Windows("win"),
    Linux("nux"),
    Other("generic");

    private static OSType detectedOS;

    private final String[] keys;

    private OSType(String... keys) {
        this.keys = keys;
    }

    private boolean match(String osKey) {
        for (int i = 0; i < keys.length; i++) {
            if (osKey.indexOf(keys[i]) != -1)
                return true;
        }
        return false;
    }

    public static OSType getOS_Type() {
        if (detectedOS == null)
            detectedOS = getOperatingSystemType(System.getProperty("os.name", Other.keys[0]).toLowerCase());
        return detectedOS;
    }

    private static OSType getOperatingSystemType(String osKey) {
        for (OSType osType : values()) {
            if (osType.match(osKey))
                return osType;
        }
        return Other;
    }
}

vous pouvez juste utiliser le soleil.awt.OSInfo # méthode getOSType ()

vous pouvez obtenir le nom du type D'OS en utilisant

System.out.println(System.getProperty("os.name"));

vous pouvez obtenir toutes les informations relatives à OS par:

public class MyFirstJavaProgram {

   public static void main(String []args) {
      System.getProperties().list(System.out);    } }

il affichera beaucoup de détails

-- liste des propriétés --

java.c'est parti.nom=OpenJDK Runtime Environment

soleil.démarrage.bibliothèque.path=/usr/lib/jvm/java-version 1.8.0-openjdk-1.8.0...

Java.vm.version = 25.65-B01

de java.vm.vendeur=Oracle Corporation

de java.Fournisseur.url = http://java.oracle.com /

chemin d'accès.séparateur=:

java.vm.nom=OpenJDK 64-Bit Server VM

fichier.encodage.pkg = soleil.io

de l'utilisateur.Pays = US

soleil.Java.lanceur = SUN_STANDARD

soleil.OS.patch.niveau=inconnu

java.vm.spécification.Nom=Spécification de machine virtuelle Java

de l'utilisateur.dir= / web / com / 1502258867_87863

de java.Runtime.version = 1.8.0_65-B17

de java.awt.graphicsenv=soleil.awt.X11environnement graphique

de java.approuver.dir=/usr/lib/jvm/java-version 1.8.0-openjdk-1.8.0...

os.arch=amd64

java.io.tmpdir=/tmp

ligne.séparateur=

de java.vm.spécification.vendeur=Oracle Corporation

os.nom = Linux

soleil.jnu.encoding=UTF-8

de java.de la bibliothèque.path=/home/cg/root/GNUstep/Library / Librari...

java.spécification.Nom=Spécification API de plate-forme Java

de java.classe.version = 52,0

soleil.gestion.compilateur=compilateurs séquentiels 64 bits

os.version=3.10.0-327.4.4.el7.x86_64

de l'utilisateur.home= / usr / share /httpd

de l'utilisateur.timezone=

de java.awt.printerjob=soleil.imprimer.PSPrinterJob

"151920920 de fichier".encoding=UTF-8

de java.spécification.version = 1.8

user.nom = apache

de java.classe.path=/home/cg/root/GNUstep/Library / Librari...

Java.vm.spécification.version = 1.8

soleil.Arch.données.modèle = 64

de java.home=/usr/lib/jvm/java-version 1.8.0-openjdk-1.8.0...

soleil.Java.command=MyFirstJavaProgram

de java.spécification.vendeur=Oracle Corporation

de l'utilisateur.langue=fr 151930920"

awt.toolkit=soleil.awt.X11.XToolkit

java.vm.info=mode mixte

Java.version = 1.8.0_65

de java.ext.dir=/usr/lib/jvm/java-version 1.8.0-openjdk-1.8.0...

soleil.démarrage.classe.path=/usr/lib/jvm/java-version 1.8.0-openjdk-1.8.0...

de java.vendeur=Oracle Corporation

"151920920 de fichier".séparateur= /

de java.Fournisseur.URL.bug= http://bugreport.sun.com/bugreport /

soleil.CPU.endian=petits

sun.io.unicode.encoding=UnicodeLittle

soleil.CPU.isalist=

ce code pour afficher toutes les informations sur le type de système d'exploitation,le nom , les informations java et ainsi de suite.

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Properties pro = System.getProperties();
    for(Object obj : pro.keySet()){
        System.out.println(" System  "+(String)obj+"     :  "+System.getProperty((String)obj));
    }
}

je pense que la suite peut donner une couverture plus large dans moins de lignes

import org.apache.commons.exec.OS;

if (OS.isFamilyWindows()){
                //load some property
            }
else if (OS.isFamilyUnix()){
                //load some other property
            }

plus de détails ici: https://commons.apache.org/proper/commons-exec/apidocs/org/apache/commons/exec/OS.html