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
*/
static native 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
*/
static native int identityHashCode(Object o);
/**
* Convert a library name to its platform-specific variant.
*
* @param libname the library name, as used in loadLibrary
* @return the platform-specific mangling of the name
* @XXX Add this method
static native String mapLibraryName(String libname);
*/
/**
* Set {@link System#in} to a new InputStream.
*
* @param in the new InputStream
* @see #setIn(InputStream)
*/
static native void setIn(InputStream in);
/**
* Set {@link System#out} to a new PrintStream.
*
* @param out the new PrintStream
* @see #setOut(PrintStream)
*/
static native void setOut(PrintStream out);
/**
* Set {@link System#err} to a new PrintStream.
*
* @param err the new PrintStream
* @see #setErr(PrintStream)
*/
static native void setErr(PrintStream err);
/**
* 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 static long currentTimeMillis()
{
return nanoTime() / 1000000L;
}
/**
* * Returns the current value of a nanosecond-precise system timer. * The value of the timer is an offset relative to some arbitrary fixed * time, which may be in the future (making the value negative). This * method is useful for timing events where nanosecond precision is * required. This is achieved by calling this method before and after the * event, and taking the difference betweent the two times: *
*
* long startTime = System.nanoTime();
* ...
* long endTime = System.nanoTime();
* long duration = endTime - startTime;
*
* Note that the value is only nanosecond-precise, and not accurate; there * is no guarantee that the difference between two values is really a * nanosecond. Also, the value is prone to overflow if the offset * exceeds 2^63. *
* * @return the time of a system timer in nanoseconds. * @since 1.5 */ public static native long nanoTime(); /** * Returns a list of 'name=value' pairs representing the current environment * variables. * * @return a list of 'name=value' pairs. */ static native List environ(); /** * Helper method which creates the standard input stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ static InputStream makeStandardInputStream() { return new BufferedInputStream(new FileInputStream(FileDescriptor.in)); } /** * Helper method which creates the standard output stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ static PrintStream makeStandardOutputStream() { return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true); } /** * Helper method which creates the standard error stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ static PrintStream makeStandardErrorStream() { return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true); } /** * Gets the value of an environment variable. * Always returning null is a valid (but not very useful) implementation. * * @param name The name of the environment variable (will not be null). * @return The string value of the variable or null when the * environment variable is not defined. */ static native String getenv(String name); }