Java ArrayUtils类代码示例

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
private void set(final long[] pFrameDurations, final int pFrameCount, final int[] pFrames, final int pFirstFrameIndex, final int pLoopCount) {
	if (pFrameDurations.length != pFrameCount) {
		throw new IllegalArgumentException("pFrameDurations does not equal pFrameCount!");
	}

	this.mFrameDurations = pFrameDurations;
	this.mFrameCount = pFrameCount;
	this.mFrames = pFrames;
	this.mFirstFrameIndex = pFirstFrameIndex;
	this.mLoopCount = pLoopCount;

	if ((this.mFrameEndsInNanoseconds == null) || (this.mFrameCount > this.mFrameEndsInNanoseconds.length)) {
		this.mFrameEndsInNanoseconds = new long[this.mFrameCount];
	}

	final long[] frameEndsInNanoseconds = this.mFrameEndsInNanoseconds;
	ArrayUtils.sumCummulative(this.mFrameDurations, TimeConstants.NANOSECONDS_PER_MILLISECOND, frameEndsInNanoseconds);

	final long lastFrameEnd = frameEndsInNanoseconds[this.mFrameCount - 1];
	this.mAnimationDuration = lastFrameEnd;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
public RadialGradientFillBitmapTextureAtlasSourceDecorator(final IBitmapTextureAtlasSource pBitmapTextureAtlasSource, final IBitmapTextureAtlasSourceDecoratorShape pBitmapTextureAtlasSourceDecoratorShape, final int[] pColors, final float[] pPositions, final RadialGradientDirection pRadialGradientDirection, final TextureAtlasSourceDecoratorOptions pTextureAtlasSourceDecoratorOptions) {
	super(pBitmapTextureAtlasSource, pBitmapTextureAtlasSourceDecoratorShape, pTextureAtlasSourceDecoratorOptions);
	this.mColors = pColors;
	this.mPositions = pPositions;
	this.mRadialGradientDirection = pRadialGradientDirection;

	this.mPaint.setStyle(Style.FILL);

	final int width = pBitmapTextureAtlasSource.getTextureWidth();
	final int height = pBitmapTextureAtlasSource.getTextureHeight();

	final float centerX = width * 0.5f;
	final float centerY = height * 0.5f;

	final float radius = Math.max(centerX, centerY);

	switch (pRadialGradientDirection) {
		case INSIDE_OUT:
			this.mPaint.setShader(new RadialGradient(centerX, centerY, radius, pColors, pPositions, TileMode.CLAMP));
			break;
		case OUTSIDE_IN:
			ArrayUtils.reverse(pColors);
			this.mPaint.setShader(new RadialGradient(centerX, centerY, radius, pColors, pPositions, TileMode.CLAMP));
			break;
	}
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, double value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        double[] nvalues = new double[n];

        // Log.e("SparseDoubleArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, byte value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        byte[] nvalues = new byte[n];

        // Log.e("SparseByteArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, long value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        long[] nvalues = new long[n];

        // Log.e("SparseLongArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, char value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        char[] nvalues = new char[n];

        // Log.e("SparseCharArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Puts a key/value pair into the array, optimizing for the case where
 * the key is greater than all existing keys in the array.
 */
public void append(int key, float value) {
    if (mSize != 0 && key <= mKeys[mSize - 1]) {
        put(key, value);
        return;
    }

    int pos = mSize;
    if (pos >= mKeys.length) {
        int n = ArrayUtils.idealIntArraySize(pos + 1);

        int[] nkeys = new int[n];
        float[] nvalues = new float[n];

        // Log.e("SparseFloatArray", "grow " + mKeys.length + " to " + n);
        System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
        System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

        mKeys = nkeys;
        mValues = nvalues;
    }

    mKeys[pos] = key;
    mValues[pos] = value;
    mSize = pos + 1;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
public RadialGradientFillBitmapTextureAtlasSourceDecorator(final IBitmapTextureAtlasSource pBitmapTextureAtlasSource, final IBitmapTextureAtlasSourceDecoratorShape pBitmapTextureAtlasSourceDecoratorShape, final int[] pColors, final float[] pPositions, final RadialGradientDirection pRadialGradientDirection, final TextureAtlasSourceDecoratorOptions pTextureAtlasSourceDecoratorOptions) {
	super(pBitmapTextureAtlasSource, pBitmapTextureAtlasSourceDecoratorShape, pTextureAtlasSourceDecoratorOptions);
	this.mColors = pColors;
	this.mPositions = pPositions;
	this.mRadialGradientDirection = pRadialGradientDirection;

	this.mPaint.setStyle(Style.FILL);

	final int width = pBitmapTextureAtlasSource.getTextureWidth();
	final int height = pBitmapTextureAtlasSource.getTextureHeight();

	final float centerX = width * 0.5f;
	final float centerY = height * 0.5f;

	final float radius = Math.max(centerX, centerY);

	switch(pRadialGradientDirection) {
		case INSIDE_OUT:
			this.mPaint.setShader(new RadialGradient(centerX, centerY, radius, pColors, pPositions, TileMode.CLAMP));
			break;
		case OUTSIDE_IN:
			ArrayUtils.reverse(pColors);
			this.mPaint.setShader(new RadialGradient(centerX, centerY, radius, pColors, pPositions, TileMode.CLAMP));
			break;
	}
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
public CardinalSplineMoveModifierConfig deepCopyReverse() {
	final CardinalSplineMoveModifierConfig copy = this.deepCopy();

	ArrayUtils.reverse(copy.mControlPointXs);
	ArrayUtils.reverse(copy.mControlPointYs);

	return copy;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
public PVRTextureHeader(final byte[] pData) {
	this.mDataByteBuffer = ByteBuffer.wrap(pData);
	this.mDataByteBuffer.rewind();
	this.mDataByteBuffer.order(ByteOrder.LITTLE_ENDIAN);

	/* Check magic bytes. */
	if (!ArrayUtils.equals(pData, 11 * DataConstants.BYTES_PER_INT, PVRTextureHeader.MAGIC_IDENTIFIER, 0, PVRTextureHeader.MAGIC_IDENTIFIER.length)) {
		throw new IllegalArgumentException("Invalid " + this.getClass().getSimpleName() + "!");
	}

	this.mPVRTextureFormat = PVRTextureFormat.fromID(this.getFlags() & PVRTextureHeader.FORMAT_FLAG_MASK);
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
public CCZHeader(final byte[] pData) {
	this.mDataByteBuffer = ByteBuffer.wrap(pData);
	this.mDataByteBuffer.rewind();
	this.mDataByteBuffer.order(ByteOrder.BIG_ENDIAN);

	/* Check magic bytes. */
	if (!ArrayUtils.equals(pData, 0, CCZHeader.MAGIC_IDENTIFIER, 0, CCZHeader.MAGIC_IDENTIFIER.length)) {
		throw new IllegalArgumentException("Invalid " + this.getClass().getSimpleName() + "!");
	}

	// TODO Check the version?

	this.mCCZCompressionFormat = CCZCompressionFormat.fromID(this.getCCZCompressionFormatID());
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseDoubleArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.
 */
public SparseDoubleArray(int initialCapacity) {
    initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);

    mKeys = new int[initialCapacity];
    mValues = new double[initialCapacity];
    mSize = 0;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Adds a mapping from the specified key to the specified value,
 * replacing the previous mapping from the specified key if there
 * was one.
 */
public void put(int key, double value) {
    int i = binarySearch(mKeys, 0, mSize, key);

    if (i >= 0) {
        mValues[i] = value;
    } else {
        i = ~i;

        if (mSize >= mKeys.length) {
            int n = ArrayUtils.idealIntArraySize(mSize + 1);

            int[] nkeys = new int[n];
            double[] nvalues = new double[n];

            // Log.e("SparseDoubleArray", "grow " + mKeys.length + " to " + n);
            System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

            mKeys = nkeys;
            mValues = nvalues;
        }

        if (mSize - i != 0) {
            // Log.e("SparseDoubleArray", "move " + (mSize - i));
            System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
            System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
        }

        mKeys[i] = key;
        mValues[i] = value;
        mSize++;
    }
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Creates a new SparseByteArray containing no mappings that will not
 * require any additional memory allocation to store the specified
 * number of mappings.
 */
public SparseByteArray(int initialCapacity) {
    initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);

    mKeys = new int[initialCapacity];
    mValues = new byte[initialCapacity];
    mSize = 0;
}
 

import org.andengine.util.adt.array.ArrayUtils; //导入依赖的package包/类
/**
 * Adds a mapping from the specified key to the specified value,
 * replacing the previous mapping from the specified key if there
 * was one.
 */
public void put(int key, byte value) {
    int i = binarySearch(mKeys, 0, mSize, key);

    if (i >= 0) {
        mValues[i] = value;
    } else {
        i = ~i;

        if (mSize >= mKeys.length) {
            int n = ArrayUtils.idealIntArraySize(mSize + 1);

            int[] nkeys = new int[n];
            byte[] nvalues = new byte[n];

            // Log.e("SparseByteArray", "grow " + mKeys.length + " to " + n);
            System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
            System.arraycopy(mValues, 0, nvalues, 0, mValues.length);

            mKeys = nkeys;
            mValues = nvalues;
        }

        if (mSize - i != 0) {
            // Log.e("SparseByteArray", "move " + (mSize - i));
            System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
            System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
        }

        mKeys[i] = key;
        mValues[i] = value;
        mSize++;
    }
}