In Properties, we examined the way an application can useProperties
objects to maintain its configuration. The Java paltform itself uses aProperties
object to maintain its own configuration. TheSystem
class maintains aProperties
object that describes the configuration of the current working environment. System properties include information about the current user, the current version of the Java runtime, and the character used to separate components of a file path name.The following table describes some of the most important system properties
Key Meaning "file.separator"
Character that separates components of a file path. This is " /
" on UNIX, and "\
" on Windows."java.class.path"
Path used to find directories and JAR archives containing class files. Elements of the class path are separated by a platform-specific character specified in the path.separator
property."java.home"
Installation directory for Java Runtime Environment (JRE). "java.vendor"
JRE vendor name "java.vendor.url"
JRE vender URL "java.version"
JRE version number "line.separator"
Sequence used by operating system to separate lines in text files. "os.arch"
Operating system architecture "os.name"
Operating system name "os.version"
Operating system version "path.separator"
Path separator character used in java.class.path
"user.dir"
User working directory "user.home"
User home directory "user.name"
User account name
Security consideration: Access to system properties can be restricted by the Security Manager. This is most often an issue in applets, which are prevented from reading some system properties, and from writing any system properties. For more on accessing system properties in applets, refer to Getting System Properties in the Applets lesson.
TheSystem
class has two methods used to read system properties:getProperty
andgetProperties
.The
System
class has two different versions ofgetProperty
. Both retrieve the value of the property named in the argument list. The simpler of the twogetProperty
methods takes a single argument, a property key For example, to get the value ofpath.separator
, use the following statement:TheSystem.getProperty("path.separator");getProperty
method returns a string containing the value of the property. If the property does not exist, this version ofgetProperty
returns null.The other version of
getProperty
requires twoString
arguments: the first argument is the key to look up and the second argument is a default value to return if the key cannot be found or if it has no value. For example, the following invocation ofgetProperty
looks up theSystem
property calledsubliminal.message
. This is not a valid system property, so instead of returning null, this method returns the default value provided as a second argument: "Buy StayPuft Marshmallows!
"System.getProperty("subliminal.message", "Buy StayPuft Marshmallows!");The last method provided by the
System
class to access property values is thegetProperties
method, which returns aProperties
object. This object contains a complete set of system property definitions.
To modify the existing set of system properties, useSystem.setProperties
. This method takes aProperties
object that has been initialized to contain the properties to be set. This method replaces the entire set of system properties with the new set represented by theProperties
object.
Warning: Changing system properties is potentially dangerous and should be done with discretion. Many system properties are not reread after start-up, and are there for informational purposes. Changing some properties may have unexpected side-effects.The next example,
, creates a
PropertiesTest
Properties
object and initializes it frommyProperties.txt
.subliminal.message=Buy StayPuft Marshmallows!PropertiesTest
then usesSystem.setProperties
to install the newProperties
objects as the current set of system properties.Note howimport java.io.FileInputStream; import java.util.Properties; public class PropertiesTest { public static void main(String[] args) throws Exception { // set up new properties object // from file "myProperties.txt" FileInputStream propFile = new FileInputStream( "myProperties.txt"); Properties p = new Properties(System.getProperties()); p.load(propFile); // set the system properties System.setProperties(p); // display new properties System.getProperties().list(System.out); } }PropertiesTest
creates theProperties
object,p
, which is used as the argument tosetProperties
:This statement initializes the new properties object,Properties p = new Properties(System.getProperties());p
with the current set of system properties, which in the case of this small application, is the set of properties initialized by the runtime system. Then the application loads additional properties intop
from the filemyProperties.txt
and sets the system properties top
. This has the effect of adding the properties listed inmyProperties.txt
to the set of properties created by the runtime system at startup. Note that an application can createp
without any defaultProperties
object like this:Properties p = new Properties();Also note that the value of system properties can be overwritten! For example, if
myProperties.txt
contains the following line, thejava.vendor
system property will be overwritten:In general, be careful not to overwrite system properties.java.vendor=Acme Software CompanyThe
setProperties
method changes the set of system properties for the current running application. These changes are not persistent. That is, changing the system properties within an application will not affect future invocations of the Java interpreter for this or any other application. The runtime system re-initializes the system properties each time its starts up. If changes to system properties are to be persistent, then the application must write the values to some file before exiting and read them in again upon startup.