proguard.util.ArrayUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of proguard-core Show documentation
Show all versions of proguard-core Show documentation
ProGuardCORE is a free library to read, analyze, modify, and write Java class files.
/*
* ProGuardCORE -- library to process Java bytecode.
*
* Copyright (c) 2002-2020 Guardsquare NV
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package proguard.util;
import java.lang.reflect.Array;
import java.util.Arrays;
/** This class contains utility methods operating on arrays. */
public class ArrayUtil {
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(boolean[] array, int size, boolean value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(byte[] array, int size, byte value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(char[] array, int size, char value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(short[] array, int size, short value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(int[] array, int size, int value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(long[] array, int size, long value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(float[] array, int size, float value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(double[] array, int size, double value) {
for (int index = 0; index < size; index++) {
if (array[index] == value) {
return index;
}
}
return -1;
}
/**
* Returns the index of the given value in the given array.
*
* @param array the array.
* @param size the size of the array to be checked.
* @param value the value to look for.
* @return the index of the value, or -1 if the value is not present.
*/
public static int indexOf(Object[] array, int size, Object value) {
for (int index = 0; index < size; index++) {
if (array[index].equals(value)) {
return index;
}
}
return -1;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(boolean[] array1, boolean[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(byte[] array1, byte[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(char[] array1, char[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(short[] array1, short[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(int[] array1, int[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(long[] array1, long[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(float[] array1, float[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(double[] array1, double[] array2, int size) {
for (int index = 0; index < size; index++) {
if (array1[index] != array2[index]) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equal(Object[] array1, Object[] array2, int size) {
for (int index = 0; index < size; index++) {
if (!array1[index].equals(array2[index])) {
return false;
}
}
return true;
}
/**
* Returns whether the elements of the two given arrays are the same, or both arrays are null.
*
* @param array1 the first array.
* @param array2 the second array.
* @return whether the elements are the same.
*/
public static boolean equalOrNull(Object[] array1, Object[] array2) {
return array1 == null ? array2 == null : equalOrNull(array1, array2, array1.length);
}
/**
* Returns whether the elements of the two given arrays are the same, or both arrays are null.
*
* @param array1 the first array.
* @param array2 the second array.
* @param size the size of the arrays to be checked.
* @return whether the elements are the same.
*/
public static boolean equalOrNull(Object[] array1, Object[] array2, int size) {
return array1 == null ? array2 == null : array2 != null && equal(array1, array2, size);
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(boolean[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
if (array[index]) {
hashCode ^= 1;
}
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(byte[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= array[index] & 0xff;
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(char[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= array[index];
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(short[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= array[index] & 0xffff;
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(int[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= array[index];
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(long[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
long longBits = array[index];
hashCode ^= longBits | (longBits >>> 32);
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(float[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= Float.floatToRawIntBits(array[index]);
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(double[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
long longBits = Double.doubleToRawLongBits(array[index]);
hashCode ^= longBits | (longBits >>> 32);
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCode(Object[] array, int size) {
int hashCode = 0;
for (int index = 0; index < size; index++) {
// Rotate the hash code.
hashCode = (hashCode << 1) | (hashCode >>> 31);
// XOR the element.
hashCode ^= array[index].hashCode();
}
return hashCode;
}
/**
* Returns a hash code for the elements of the given array, or 0 if it is null.
*
* @param array the array.
* @return a hash code.
*/
public static int hashCodeOrNull(Object[] array) {
return array == null ? 0 : hashCode(array, array.length);
}
/**
* Returns a hash code for the elements of the given array, or 0 if it is null.
*
* @param array the array.
* @param size the size of the array to be taken into account.
* @return a hash code.
*/
public static int hashCodeOrNull(Object[] array, int size) {
return array == null ? 0 : hashCode(array, size);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(boolean[] array1, int size1, boolean[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Boolean.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(byte[] array1, int size1, byte[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Byte.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(char[] array1, int size1, char[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Character.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(short[] array1, int size1, short[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Short.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(int[] array1, int size1, int[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Integer.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(long[] array1, int size1, long[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Long.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(float[] array1, int size1, float[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Float.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(double[] array1, int size1, double[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = Double.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Compares the elements of the two given arrays.
*
* @param array1 the first array.
* @param size1 the size of the first array.
* @param array2 the second array.
* @param size2 the size of the second array.
* @return 0 if all elements are the same, -1 if the first different element in the first array is
* smaller than the corresponding element in the second array, or 1 if it is larger.
*/
public static int compare(Comparable[] array1, int size1, Comparable[] array2, int size2) {
int minSize = Math.min(size1, size2);
for (int index = 0; index < minSize; index++) {
int comparison = ObjectUtil.compare(array1[index], array2[index]);
if (comparison != 0) {
return comparison;
}
}
return Integer.compare(size1, size2);
}
/**
* Returns a shallow copy of the given array, or null if the input is null.
*
* @param array the array.
* @return a shallow copy of the original array, or null if the array is null.
*/
public static T[] cloneOrNull(T[] array) {
return array != null ? array.clone() : null;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static boolean[] extendArray(boolean[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
boolean[] newArray = new boolean[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static boolean[] ensureArraySize(boolean[] array, int size, boolean initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new boolean[size];
if (initialValue) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static byte[] add(byte[] array, int size, byte element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static byte[] insert(byte[] array, int size, int index, byte element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(byte[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static byte[] extendArray(byte[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
byte[] newArray = new byte[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static byte[] ensureArraySize(byte[] array, int size, byte initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new byte[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static char[] add(char[] array, int size, char element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static char[] insert(char[] array, int size, int index, char element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(char[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static char[] extendArray(char[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
char[] newArray = new char[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static char[] ensureArraySize(char[] array, int size, char initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new char[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static short[] add(short[] array, int size, short element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static short[] insert(short[] array, int size, int index, short element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(short[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static short[] extendArray(short[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
short[] newArray = new short[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static short[] ensureArraySize(short[] array, int size, short initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new short[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static int[] add(int[] array, int size, int element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static int[] insert(int[] array, int size, int index, int element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(int[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static int[] extendArray(int[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
int[] newArray = new int[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static int[] ensureArraySize(int[] array, int size, int initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new int[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static long[] add(long[] array, int size, long element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static long[] insert(long[] array, int size, int index, long element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(long[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static long[] extendArray(long[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
long[] newArray = new long[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static long[] ensureArraySize(long[] array, int size, long initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new long[size];
if (initialValue != 0L) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static float[] add(float[] array, int size, float element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static float[] insert(float[] array, int size, int index, float element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(float[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static float[] extendArray(float[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
float[] newArray = new float[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static float[] ensureArraySize(float[] array, int size, float initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new float[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static double[] add(double[] array, int size, double element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static double[] insert(double[] array, int size, int index, double element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(double[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = 0;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static double[] extendArray(double[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
double[] newArray = new double[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static double[] ensureArraySize(double[] array, int size, double initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = new double[size];
if (initialValue != 0) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/**
* Adds the given element to the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static T[] add(T[] array, int size, T element) {
array = extendArray(array, size + 1);
array[size] = element;
return array;
}
/**
* Inserts the given element in the given array. The array is extended if necessary.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index at which the element is to be added.
* @param element the element to be added.
* @return the original array, or a copy if it had to be extended.
*/
public static T[] insert(T[] array, int size, int index, T element) {
array = extendArray(array, size + 1);
// Move the last part.
System.arraycopy(array, index, array, index + 1, size - index);
array[index] = element;
return array;
}
/**
* Removes the specified element from the given array.
*
* @param array the array.
* @param size the original size of the array.
* @param index the index of the element to be removed.
*/
public static void remove(Object[] array, int size, int index) {
System.arraycopy(array, index + 1, array, index, array.length - index - 1);
array[size - 1] = null;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @return the original array, or a copy if it had to be extended.
*/
public static T[] extendArray(T[] array, int size) {
// Reuse the existing array if possible.
if (array.length >= size) {
return array;
}
// Otherwise create and initialize a new array.
T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), size);
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
/**
* Ensures the given array has a given size.
*
* @param array the array.
* @param size the target size of the array.
* @param initialValue the initial value of the elements.
* @return the original array, or a copy if it had to be extended.
*/
public static T[] ensureArraySize(T[] array, int size, T initialValue) {
// Is the existing array large enough?
if (array.length >= size) {
// Reinitialize the existing array.
Arrays.fill(array, 0, size, initialValue);
} else {
// Otherwise create and initialize a new array.
array = (T[]) Array.newInstance(array.getClass().getComponentType(), size);
if (initialValue != null) {
Arrays.fill(array, 0, size, initialValue);
}
}
return array;
}
/** Concatenates two arrays into a single one. */
public static T[] concat(T[] first, T[] second) {
T[] result = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, result, first.length, second.length);
return result;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy