array.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 636 行 · 第 1/2 页

		if (array instanceof char[])
			return ((char[]) array)[index];
		return getShort(array, index);
	}

	/**
	 * Gets an element of a long array.
	 *
	 * @param array the array to access
	 * @param index the array index to access
	 * @return the long element at <code>array[index]</code>
	 * @throws IllegalArgumentException  if <code>array</code> is not a byte,
	 *         char, short, int, or long array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #get(Object, int)
	 */
	public static long getLong(Object array, int index) {
		if (array instanceof long[])
			return ((long[]) array)[index];
		return getInt(array, index);
	}

	/**
	 * Gets an element of a float array.
	 *
	 * @param array the array to access
	 * @param index the array index to access
	 * @return the float element at <code>array[index]</code>
	 * @throws IllegalArgumentException  if <code>array</code> is not a byte,
	 *         char, short, int, long, or float array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #get(Object, int)
	 */
	public static float getFloat(Object array, int index) {
		if (array instanceof float[])
			return ((float[]) array)[index];
		return getLong(array, index);
	}

	/**
	 * Gets an element of a double array.
	 *
	 * @param array the array to access
	 * @param index the array index to access
	 * @return the double element at <code>array[index]</code>
	 * @throws IllegalArgumentException  if <code>array</code> is not a byte,
	 *         char, short, int, long, float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #get(Object, int)
	 */
	public static double getDouble(Object array, int index) {
		if (array instanceof double[])
			return ((double[]) array)[index];
		return getFloat(array, index);
	}

	/**
	 * Sets an element of an array. If the array is primitive, then the new
	 * value is unwrapped and widened.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not an array,
	 *         or the array is primitive and unwrapping value fails, or the
	 *         value is not assignable to the array component type
	 * @throws NullPointerException if array is null, or if array is primitive
	 *         and value is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #setBoolean(Object, int, boolean)
	 * @see #setByte(Object, int, byte)
	 * @see #setChar(Object, int, char)
	 * @see #setShort(Object, int, short)
	 * @see #setInt(Object, int, int)
	 * @see #setLong(Object, int, long)
	 * @see #setFloat(Object, int, float)
	 * @see #setDouble(Object, int, double)
	 */
	public static void set(Object array, int index, Object value) {
		if (array instanceof Object[]) {
			// Too bad Sun won't let us throw the easier ArrayStoreException!
			if (!array.getClass().getComponentType().isInstance(value))
				throw new IllegalArgumentException();
			((Object[]) array)[index] = value;
		} else if (value instanceof Boolean)
			setBoolean(array, index, ((Boolean) value).booleanValue());
		else if (value instanceof Byte)
			setByte(array, index, ((Byte) value).byteValue());
		else if (value instanceof Character)
			setChar(array, index, ((Character) value).charValue());
		else if (value instanceof Short)
			setShort(array, index, ((Short) value).shortValue());
		else if (value instanceof Integer)
			setInt(array, index, ((Integer) value).intValue());
		else if (value instanceof Long)
			setLong(array, index, ((Long) value).longValue());
		else if (value instanceof Float)
			setFloat(array, index, ((Float) value).floatValue());
		else if (value instanceof Double)
			setDouble(array, index, ((Double) value).doubleValue());
		else if (array == null)
			throw new NullPointerException();
		else
			throw new IllegalArgumentException();
	}

	/**
	 * Sets an element of a boolean array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a boolean
	 *         array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setBoolean(Object array, int index, boolean value) {
		if (array instanceof boolean[])
			 ((boolean[]) array)[index] = value;
		else if (array == null)
			throw new NullPointerException();
		else
			throw new IllegalArgumentException();
	}

	/**
	 * Sets an element of a byte array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a byte,
	 *         short, int, long, float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setByte(Object array, int index, byte value) {
		if (array instanceof byte[])
			 ((byte[]) array)[index] = value;
		else
			setShort(array, index, value);
	}

	/**
	 * Sets an element of a char array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a char,
	 *         int, long, float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setChar(Object array, int index, char value) {
		if (array instanceof char[])
			 ((char[]) array)[index] = value;
		else
			setInt(array, index, value);
	}

	/**
	 * Sets an element of a short array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a short,
	 *         int, long, float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setShort(Object array, int index, short value) {
		if (array instanceof short[])
			 ((short[]) array)[index] = value;
		else
			setInt(array, index, value);
	}

	/**
	 * Sets an element of an int array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not an int,
	 *         long, float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setInt(Object array, int index, int value) {
		if (array instanceof int[])
			 ((int[]) array)[index] = value;
		else
			setLong(array, index, value);
	}

	/**
	 * Sets an element of a long array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a long,
	 *         float, or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setLong(Object array, int index, long value) {
		if (array instanceof long[])
			 ((long[]) array)[index] = value;
		else
			setFloat(array, index, value);
	}

	/**
	 * Sets an element of a float array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a float
	 *         or double array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setFloat(Object array, int index, float value) {
		if (array instanceof float[])
			 ((float[]) array)[index] = value;
		else
			setDouble(array, index, value);
	}

	/**
	 * Sets an element of a double array.
	 *
	 * @param array the array to set a value of
	 * @param index the array index to set the value to
	 * @param value the value to set
	 * @throws IllegalArgumentException if <code>array</code> is not a double
	 *         array
	 * @throws NullPointerException if <code>array</code> is null
	 * @throws ArrayIndexOutOfBoundsException if <code>index</code> is out of
	 *         bounds
	 * @see #set(Object, int, Object)
	 */
	public static void setDouble(Object array, int index, double value) {
		if (array instanceof double[])
			 ((double[]) array)[index] = value;
		else if (array == null)
			throw new NullPointerException();
		else
			throw new IllegalArgumentException();
	}

	/**
	 * Dynamically and recursively create a multi-dimensioned array of objects.
	 *
	 * @param type guaranteed to be a valid object type
	 * @param dimensions the dimensions of the array
	 * @param index index of the current dimension to build
	 * @return the new multi-dimensioned array
	 * @throws NegativeArraySizeException if any entry of dimensions is negative
	 * @throws OutOfMemoryError if memory allocation fails
	 */
	// This would be faster if implemented natively, using the multianewarray
	// bytecode instead of this recursive call
	private static Object createMultiArray(Class type, int[] dimensions, int index) {
		if (index == 0)
			return newInstance(type, dimensions[0]);

		Object toAdd = createMultiArray(type, dimensions, index - 1);
		Class thisType = toAdd.getClass();
		Object[] retval = (Object[]) createObjectArray(thisType, dimensions[index]);
		if (dimensions[index] > 0)
			retval[0] = toAdd;
		int i = dimensions[index];
		while (--i > 0)
			retval[i] = createMultiArray(type, dimensions, index - 1);
		return retval;
	}

	/**
	 * Dynamically create an array of objects.
	 *
	 * @param type guaranteed to be a valid object type
	 * @param dim the length of the array
	 * @return the new array
	 * @throws NegativeArraySizeException if dim is negative
	 * @throws OutOfMemoryError if memory allocation fails
	 */
	private static Object createObjectArray(Class type, int dim) {
		return null;
	}
}