This corresponds to the C stdout and C++ cout variables, which * typically output normal messages to the screen, but may be used to pipe * output to other processes or files. That should all be transparent to * you, however. */ public static final PrintStream out = System.makeStandardOutputStream(); /** * The standard output PrintStream. This is assigned at startup and * starts its life perfectly valid. * *
This corresponds to the C stderr and C++ cerr variables, which
* typically output error messages to the screen, but may be used to pipe
* output to other processes or files. That should all be transparent to
* you, however.
*/
public static final PrintStream err = System.makeStandardErrorStream();
/**
* This class is uninstantiable.
*/
private System()
{
}
/**
* Get the current time, measured in the number of milliseconds from the
* beginning of Jan. 1, 1970. This is gathered from the system clock, with
* any attendant incorrectness (it may be timezone dependent).
*
* @return the current time
* @see java.util.Date
*/
public native static long currentTimeMillis();
/**
* Copy one array onto another from src[srcStart] ...
* src[srcStart+len-1] to dest[destStart] ...
* dest[destStart+len-1]. First, the arguments are validated:
* neither array may be null, they must be of compatible types, and the
* start and length must fit within both arrays. Then the copying starts,
* and proceeds through increasing slots. If src and dest are the same
* array, this will appear to copy the data to a temporary location first.
* An ArrayStoreException in the middle of copying will leave earlier
* elements copied, but later elements unchanged.
*
* @param src the array to copy elements from
* @param srcStart the starting position in src
* @param dest the array to copy elements to
* @param destStart the starting position in dest
* @param len the number of elements to copy
* @throws NullPointerException if src or dest is null
* @throws ArrayStoreException if src or dest is not an array, if they are
* not compatible array types, or if an incompatible runtime type
* is stored in dest
* @throws IndexOutOfBoundsException if len is negative, or if the start or
* end copy position in either array is out of bounds
*/
public native static void arraycopy(Object src, int srcStart, Object dest,
int destStart, int len);
/**
* Get a hash code computed by the VM for the Object. This hash code will
* be the same as Object's hashCode() method. It is usually some
* convolution of the pointer to the Object internal to the VM. It
* follows standard hash code rules, in that it will remain the same for a
* given Object for the lifetime of that Object.
*
* @param o the Object to get the hash code for
* @return the VM-dependent hash code for this Object
* @since 1.1
*/
public native static int identityHashCode(Object o);
/**
* Get a single system property by name. A security check may be performed,
* checkPropertyAccess(key).
*
* @param key the name of the system property to get
* @return the property, or null if not found
* @throws NullPointerException if key is null
* @throws IllegalArgumentException if key is ""
*/
public static String getProperty(String key)
{
if (key.equals(""))
throw new IllegalArgumentException();
else
{
if (key.equals("line.separator"))
return "\n";
else if (key.equals("microedition.platform"))
return "jelatine";
else if (key.equals("microedition.encoding"))
return "ISO-8859-1";
else if (key.equals("microedition.configuration"))
return "CLDC-1.1";
else if (key.equals("microedition.profiles"))
return null; // To be added by the profile implementation
else
return null;
}
}
/**
* Terminate the Virtual Machine. This just calls
* Runtime.getRuntime().exit(status), and never returns.
* Obviously, a security check is in order, checkExit.
*
* @param status the exit status; by convention non-zero is abnormal
* @see Runtime#exit(int)
*/
public static void exit(int status)
{
Runtime.getRuntime().exit(status);
}
/**
* Calls the garbage collector. This is only a hint, and it is up to the
* implementation what this hint suggests, but it usually causes a
* best-effort attempt to reclaim unused memory from discarded objects.
* This calls Runtime.getRuntime().gc().
*
* @see Runtime#gc()
*/
public static void gc()
{
Runtime.getRuntime().gc();
}
/**
* Creates the standard error stream
* @returns A reference to the standard error stream
*/
private static PrintStream makeStandardErrorStream()
{
OutputStream stderr = new VMOutputStream("stderr");
return new PrintStream(stderr);
}
/**
* Creates the standard output stream
* @returns A reference to the standard output stream
*/
private static PrintStream makeStandardOutputStream()
{
OutputStream stdout = new VMOutputStream("stdout");
return new PrintStream(stdout);
}
public static native void loadLibrary(String libname);
} // class System