public final class System extends Object
System class contains several useful class fields and methods. It cannot be
 instantiated.
 
 Among the facilities provided by the System class are standard input, standard
 output, and error output streams; access to externally defined properties and environment
 variables; and a utility method for quickly copying a portion of an array.
| Modifier and Type | Field and Description | 
|---|---|
| static PrintStream | errThe "standard" error output stream. | 
| static PrintStream | outThe "standard" output stream. | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | arraycopy(Object src,
         int srcPos,
         Object dest,
         int destPos,
         int length)Copies an array from the specified source array, beginning at the specified position, to the
 specified position of the destination array. | 
| static long | currentTimeMillis()Returns the current time in milliseconds. | 
| static void | exit(int status)Terminates the currently running Java Virtual Machine. | 
| static void | gc()Runs the garbage collector. | 
| static String | getProperty(String key)Gets the system property indicated by the specified key. | 
| static String | getProperty(String key,
           String def)Gets the system property indicated by the specified key. | 
| static SecurityManager | getSecurityManager()Gets the system security interface. | 
| static int | identityHashCode(Object x)Returns the same hash code for the given object as would be returned by the default method
 hashCode(), whether or not the given object's class overrides hashCode(). | 
| static long | nanoTime()Returns the current value of the running Java Virtual Machine's high-resolution time source, in
 nanoseconds. | 
| static void | setSecurityManager(SecurityManager s)Sets the System security. | 
public static final PrintStream err
 Typically this stream corresponds to display output or another output destination specified by
 the host environment or user. By convention, this output stream is used to display error messages
 or other information that should come to the immediate attention of a user even if the principal
 output stream, the value of the variable out, has been redirected to a file or other
 destination that is typically not continuously monitored.
public static final PrintStream out
For simple stand-alone Java applications, a typical way to write a line of output data is:
System.out.println(data)
 See the println methods in class PrintStream.
PrintStream.println(), 
PrintStream.println(boolean), 
PrintStream.println(char), 
PrintStream.println(char[]), 
PrintStream.println(double), 
PrintStream.println(float), 
PrintStream.println(int), 
PrintStream.println(long), 
PrintStream.println(java.lang.Object), 
PrintStream.println(java.lang.String)public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src to the destination array referenced by
 dest. The number of components copied is equal to the length argument.
 The components at positions srcPos through srcPos+length-1 in the
 source array are copied into positions destPos through
 destPos+length-1, respectively, of the destination array.
 
 If the src and dest arguments refer to the same array object, then the
 copying is performed as if the components at positions srcPos through
 srcPos+length-1 were first copied to a temporary array with length
 components and then the contents of the temporary array were copied into positions
 destPos through destPos+length-1 of the destination array.
 
 If dest is null, then a NullPointerException is thrown.
 
 If src is null, then a NullPointerException is thrown and
 the destination array is not modified.
 
 Otherwise, if any of the following is true, an ArrayStoreException is thrown and the
 destination is not modified:
 
src argument refers to an object that is not an array.
 dest argument refers to an object that is not an array.
 src argument and dest argument refer to arrays whose component
 types are different primitive types.
 src argument refers to an array with a primitive component type and the
 dest argument refers to an array with a reference component type.
 src argument refers to an array with a reference component type and the
 dest argument refers to an array with a primitive component type.
 
 Otherwise, if any of the following is true, an IndexOutOfBoundsException is thrown
 and the destination is not modified:
 
srcPos argument is negative.
 destPos argument is negative.
 length argument is negative.
 srcPos+length is greater than src.length, the length of the source
 array.
 destPos+length is greater than dest.length, the length of the
 destination array.
 
 Otherwise, if any actual component of the source array from position srcPos through
 srcPos+length-1 cannot be converted to the component type of the destination array
 by assignment conversion, an ArrayStoreException is thrown. In this case, let
 k be the smallest nonnegative integer less than length such that
 src[srcPos+k] cannot be converted to the component type of the
 destination array; when the exception is thrown, source array components from positions
 srcPos through srcPos+k-1 will already have been
 copied to destination array positions destPos through destPos+
 k-1 and no other positions of the destination array will have been modified.
 (Because of the restrictions already itemized, this paragraph effectively applies only to the
 situation where both arrays have component types that are reference types.)
src - the source array.srcPos - starting position in the source array.dest - the destination array.destPos - starting position in the destination data.length - the number of array elements to be copied.IndexOutOfBoundsException - if copying would cause access of data outside array bounds.ArrayStoreException - if an element in the src array could not be stored into the
            dest array because of a type mismatch.NullPointerException - if either src or dest is null.public static long currentTimeMillis()
 See the description of the class Date for a discussion of slight discrepancies that
 may arise between "computer time" and coordinated universal time (UTC).
Datepublic static void exit(int status)
 This method calls the exit method in class Runtime. This method never
 returns normally.
 
 The call System.exit(n) is effectively equivalent to the call: 
Runtime.getRuntime().exit(n)
status - exit status.SecurityException - if a security manager exists and its checkExit method doesn't allow exit
         with the specified status.Runtime.exit(int)public static void gc()
 Calling the gc method suggests that the Java Virtual Machine expend effort toward
 recycling unused objects in order to make the memory they currently occupy available for quick
 reuse. When control returns from the method call, the Java Virtual Machine has made a best effort
 to reclaim space from all discarded objects.
 
 The call System.gc() is effectively equivalent to the call: 
Runtime.getRuntime().gc()
Runtime.gc()@Nullable public static String getProperty(String key)
 First, if there is a security manager, its checkPropertyAccess method is called with
 the key as its argument. This may result in a SecurityException.
 
 If there is no current set of system properties, a set of system properties is first created and
 initialized in the same manner as for the getProperties method.
key - the name of the system property.null if there is no property
         with that key.SecurityException - if a security manager exists and its checkPropertyAccess method doesn't
            allow access to the specified system property.NullPointerException - if key is null.IllegalArgumentException - if key is empty.SecurityExceptionpublic static String getProperty(String key, String def)
 First, if there is a security manager, its checkPropertyAccess method is called with
 the key as its argument.
 
 If there is no current set of system properties, a set of system properties is first created and
 initialized in the same manner as for the getProperties method.
key - the name of the system property.def - a default value.SecurityException - if a security manager exists and its checkPropertyAccess method doesn't
            allow access to the specified system property.NullPointerException - if key is null.IllegalArgumentException - if key is empty.@Nullable public static SecurityManager getSecurityManager()
null is returned.setSecurityManager(java.lang.SecurityManager)public static int identityHashCode(@Nullable Object x)
x - object for which the hashCode is to be calculatedpublic static long nanoTime()
This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary origin time (perhaps in the future, so values may be negative). The same origin is used by all invocations of this method in an instance of a Java virtual machine; other virtual machine instances are likely to use a different origin.
 This method provides nanosecond precision, but not necessarily nanosecond resolution (that is,
 how frequently the value changes) - no guarantees are made except that the resolution is at least
 as good as that of currentTimeMillis().
 
Differences in successive calls that span greater than approximately 292 years (263 nanoseconds) will not correctly compute elapsed time due to numerical overflow.
The values returned by this method become meaningful only when the difference between two such values, obtained within the same instance of a Java virtual machine, is computed.
For example, to measure how long some code takes to execute:
 {
        @code
        long startTime = System.nanoTime();
        // ... the code being measured ...
        long estimatedTime = System.nanoTime() - startTime;
 }
 
 To compare two nanoTime values
 
 long t0 = System.nanoTime();
 ...
 long t1 = System.nanoTime();
 
 one should use t1 - t0 < 0, not t1 < t0, because of the possibility of numerical
 overflow.public static void setSecurityManager(@Nullable SecurityManager s)
 If there is a security manager already installed, this method first calls the security manager's
 checkPermission method with a RuntimePermission("setSecurityManager")
 permission to ensure it's ok to replace the existing security manager. This may result in
 throwing a SecurityException.
 
 Otherwise, the argument is established as the current security manager. If the argument is
 null and no security manager has been established, then no action is taken and the
 method simply returns.
s - the security manager.SecurityException - if the security manager has already been set and its checkPermission
            method doesn't allow it to be replaced.getSecurityManager(), 
SecurityManager.checkPermission(java.security.Permission), 
RuntimePermission