配列、 (int[] のような)プリミティブ型の配列、
* (Integer[] のような)プリミティブ型のラッパーの配列に対する処理です。
* {@primary Operations on arrays, primitive arrays (like int[]) and primitive wrapper arrays
* (like Integer[]).}
このクラスは null の入力を問題なく扱えるよう試みます。
* null の配列が入力されれも冷害は発生しません。
* しかし、null の要素をもつ Object の配列が渡された場合には例外を投げます。
* 各メソッドのドキュメントに各動作が記載されています。
* {@primary This class tries to handle null input gracefully.
* An exception will not be thrown for a null
* array input. However, an Object array that contains a null
* element may throw an exception. Each method documents its behaviour.}
Object の空の配列です。
* {@primary An empty immutable Object array.}
*/
public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
/**
* 不変(immutable)な Class の空の配列です。
* {@primary An empty immutable Class array.}
*/
public static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
/**
* 不変(immutable)な String の空の配列です。
* {@primary An empty immutable String array.}
*/
public static final String[] EMPTY_STRING_ARRAY = new String[0];
/**
* 不変(immutable)な long の空の配列です。
* {@primary An empty immutable long array.}
*/
public static final long[] EMPTY_LONG_ARRAY = new long[0];
/**
* 不変(immutable)な Long の空の配列です。
* {@primary An empty immutable Long array.}
*/
public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
/**
* 不変(immutable)な int の空の配列です。
* {@primary An empty immutable int array.}
*/
public static final int[] EMPTY_INT_ARRAY = new int[0];
/**
* 不変(immutable)な Integer の空の配列です。
* {@primary An empty immutable Integer array.}
*/
public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
/**
* 不変(immutable)な short の空の配列です。
* {@primary An empty immutable short array.}
*/
public static final short[] EMPTY_SHORT_ARRAY = new short[0];
/**
* 不変(immutable)な Short の空の配列です。
* {@primary An empty immutable Short array.}
*/
public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
/**
* 不変(immutable)な byte の空の配列です。
* {@primary An empty immutable byte array.}
*/
public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
/**
* 不変(immutable)な Byte の空の配列です。
* {@primary An empty immutable Byte array.}
*/
public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
/**
* 不変(immutable)な double の空の配列です。
* {@primary An empty immutable double array.}
*/
public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
/**
* 不変(immutable)な Double の空の配列です。
* {@primary An empty immutable Double array.}
*/
public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];
/**
* 不変(immutable)な float の空の配列です。
* {@primary An empty immutable float array.}
*/
public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
/**
* 不変(immutable)な Float の空の配列です。
* {@primary An empty immutable Float array.}
*/
public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
/**
* 不変(immutable)な boolean の空の配列です。
* {@primary An empty immutable boolean array.}
*/
public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
/**
* 不変(immutable)な Boolean の空の配列です。
* {@primary An empty immutable Boolean array.}
*/
public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];
/**
* 不変(immutable)な char の空の配列です。
* {@primary An empty immutable char array.}
*/
public static final char[] EMPTY_CHAR_ARRAY = new char[0];
/**
* 不変(immutable)な Character の空の配列です。
* {@primary An empty immutable Character array.}
*/
public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];
/**
* ArrayUtils のインスタンスは一般的なプログラムからは生成すべきではありません。
* 代わりに ArrayUtils.clone(new int[] {2}) というように使用すべきです。
* {@primary ArrayUtils instances should NOT be constructed in standard programming.
* Instead, the class should be used as ArrayUtils.clone(new int[] {2}).}
このコンストラクタは、処理のために JavaBean インスタンスを必要とするツールのために * public になっています。 * {@primary This constructor is public to permit tools that require a JavaBean instance * to operate.}
*/ public ArrayUtils() { } // Basic methods handling multi-dimensional arrays //----------------------------------------------------------------------- /** *配列の文字列表現を返します。null が指定された場合には空の配列として扱います。
* {@primary Outputs an array as a String, treating null as an empty array.}
多次元配列も正しく処理されます(プリミティブ型の多次元配列も)。 * {@primary Multi-dimensional arrays are handled correctly, including * multi-dimensional primitive arrays.}
* *出力フォーマットは ({a,b} のような)Java のソースコードに近い形になります。
* {@primary The format is that of Java source code, for example {a,b}.}
null を許容します
* {@primary the array to get a toString for, may be null}
* @return 配列の文字列表現、null の配列が指定された場合 '{}'
* {@primary a String representation of the array, '{}' if null array input}
*/
public static String toString(final Object array) {
return toString(array, "{}");
}
/**
* null が指定された場合にも正常に動作し、配列の文字列表現を返します。
* {@primary Outputs an array as a String handling nulls.}
多次元配列も正しく処理されます(プリミティブ型の多次元配列も)。 * {@primary Multi-dimensional arrays are handled correctly, including * multi-dimensional primitive arrays.}
* *出力フォーマットは ({a,b} のような)Java のソースコードに近い形になります。
* {@primary The format is that of Java source code, for example {a,b}.}
null を許容します
* {@primary the array to get a toString for, may be null}
* @param stringIfNull 配列が null だった場合に返される文字列
* {@primary the String to return if the array is null}
* @return 配列の文字列表現
* {@primary a String representation of the array}
*/
public static String toString(final Object array, final String stringIfNull) {
if (array == null) {
return stringIfNull;
}
return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString();
}
/**
* 配列のハッシュコードを取得します。多次元配列も正しく処理されます。 * {@primary Get a hashCode for an array handling multi-dimensional arrays correctly.}
* *このメソッドはプリミティブ型の多次元配列も正しく処理します。 * {@primary Multi-dimensional primitive arrays are also handled correctly by this method.}
* * @param array ハッシュコードをを取得する配列、null を許容します
* {@primary the array to get a hashCode for, may be null}
* @return 配列のハッシュコード、null の場合には0
* {@primary a hashCode for the array, zero if null array input}
*/
public static int hashCode(final Object array) {
return new HashCodeBuilder().append(array).toHashCode();
}
/**
* equals() を使用して配列を比較します。多次元配列も正しく処理されます。 * {@primary Compares two arrays, using equals(), handling multi-dimensional arrays * correctly.}
* *このメソッドはプリミティブ型の多次元配列も正しく処理します。 * {@primary Multi-dimensional primitive arrays are also handled correctly by this method.}
* * @param array1 ハッシュコードをを取得する配列、null を許容します
* {@primary the array to get a hashCode for, may be null}
* @param array2 ハッシュコードをを取得する配列、null を許容します
* {@primary the array to get a hashCode for, may be null}
* @return 配列が等しい場合、true
* {@primary true if the arrays are equal}
*/
public static boolean isEquals(final Object array1, final Object array2) {
return new EqualsBuilder().append(array1, array2).isEquals();
}
// To map
//-----------------------------------------------------------------------
/**
* 配列を {@link java.util.Map} に変換します。配列の各要素は {@link java.util.Map.Entry} * または2つ以上の要素を持つ配列(1つ目の要素がキー、2つ目の要素が値になります)でなくてはなりません。 * {@primary Converts the given array into a {@link java.util.Map}. Each element of the array * must be either a {@link java.util.Map.Entry} or an Array, containing at least two * elements, where the first element is used as key and the second as * value.
* *このメソッドは以下のような初期化処理に使用することが出来ます: * {@primary This method can be used to initialize:}
*
* // Create a Map mapping colors.
* Map colorMap = MapUtils.toMap(new String[][] {{
* {"RED", "#FF0000"},
* {"GREEN", "#00FF00"},
* {"BLUE", "#0000FF"}});
*
*
* このメソッドは null の配列が指定された場合には null を返します。
* {@primary This method returns null if null array input.}
null を許容します
* {@primary an array whose elements are either a {@link java.util.Map.Entry} or
* an Array containing at least two elements, may be null}
* @return 配列から生成された Map
* {@primary a Map that was created from the array}
* @throws IllegalArgumentException 配列の要素が配列だった場合に要素数が2よりも少なかった場合
* {@primary if one element of this Array is
* itself an Array containing less then two elements}
* @throws IllegalArgumentException 配列の要素が {@link java.util.Map.Entry} または配列以外だった場合
* {@primary if the array contains elements other
* than {@link java.util.Map.Entry} and an Array}
*/
public static Map toMap(final Object[] array) {
if (array == null) {
return null;
}
final Map map = new HashMap((int) (array.length * 1.5));
for (int i = 0; i < array.length; i++) {
Object object = array[i];
if (object instanceof Map.Entry) {
Map.Entry entry = (Map.Entry) object;
map.put(entry.getKey(), entry.getValue());
} else if (object instanceof Object[]) {
Object[] entry = (Object[]) object;
if (entry.length < 2) {
throw new IllegalArgumentException("Array element " + i + ", '"
+ object
+ "', has a length less than 2");
}
map.put(entry[0], entry[1]);
} else {
throw new IllegalArgumentException("Array element " + i + ", '"
+ object
+ "', is neither of type Map.Entry nor an Array");
}
}
return map;
}
// Clone
//-----------------------------------------------------------------------
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static Object[] clone(final Object[] array) {
if (array == null) {
return null;
}
return (Object[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static long[] clone(final long[] array) {
if (array == null) {
return null;
}
return (long[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static int[] clone(int[] array) {
if (array == null) {
return null;
}
return (int[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static short[] clone(final short[] array) {
if (array == null) {
return null;
}
return (short[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static char[] clone(final char[] array) {
if (array == null) {
return null;
}
return (char[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static byte[] clone(final byte[] array) {
if (array == null) {
return null;
}
return (byte[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static double[] clone(final double[] array) {
if (array == null) {
return null;
}
return (double[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static float[] clone(final float[] array) {
if (array == null) {
return null;
}
return (float[]) array.clone();
}
/**
* 配列のクローンを生成して返します(null も処理します)。
* {@primary Clones an array returning a typecast result and handling
* null.}
This method returns null if null array input.
null を許容する配列
* {@primary the array to clone, may be null}
* @return クローンされた配列、null が指定された場合には null
* {@primary the cloned array, null if null input}
*/
public static boolean[] clone(final boolean[] array) {
if (array == null) {
return null;
}
return (boolean[]) array.clone();
}
// Is same length
//-----------------------------------------------------------------------
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final Object[] array1, final Object[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final long[] array1, final long[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final int[] array1, final int[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final short[] array1, final short[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final char[] array1, final char[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final byte[] array1, final byte[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final double[] array1, final double[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final float[] array1, final float[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の長さが同じであるかどうかをチェックします。
* null の配列の長さは0とみなされます。
* {@primary Checks whether two arrays are the same length, treating
* null arrays as length 0.}
*
*
配列の多次元要素は無視されます。 * {@primary Any multi-dimensional aspects of the arrays are ignored.}
* * @param array1 1つ目の配列、null を許容します
* {@primary the first array, may be null}
* @param array2 2つ目の配列、null を許容します
* {@primary the second array, may be null}
* @return 配列の長さが等しい場合 true、 null は空の配列とみなされます
* {@primary true if length of arrays matches, treating
* null as an empty array}
*/
public static boolean isSameLength(final boolean[] array1, final boolean[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
(array1 != null && array2 != null && array1.length != array2.length)) {
return false;
}
return true;
}
/**
* 2つの配列の型と次元宣言が等しいかどうかをチェックします。 * {@primary Checks whether two arrays are the same type taking into account * multi-dimensional arrays.}
* * @param array1 1つ目の配列、null を許容しません
* {@primary the first array, must not be null}
* @param array2 2つ目の配列、null を許容しません
* {@primary the second array, must not be null}
* @return 2つの配列が同じ宣言の場合 true
* {@primary true if type of arrays matches}
* @throws IllegalArgumentException どちらかの配列が null の場合
* {@primary if either array is null}
*/
public static boolean isSameType(final Object array1, final Object array2) {
if (array1 == null || array2 == null) {
throw new IllegalArgumentException("The Array must not be null");
}
return array1.getClass().getName().equals(array2.getClass().getName());
}
// Reverse
//-----------------------------------------------------------------------
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *多次元配列を考慮した処理は行われません。 * {@primary There is no special handling for multi-dimensional arrays.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final Object[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
Object tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final long[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
long tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final int[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
int tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final short[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
short tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final char[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
char tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final byte[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
byte tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final double[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
double tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final float[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
float tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
/**
* 渡された配列の並び順を逆にします。 * {@primary Reverses the order of the given array.}
* *このメソッドは null の配列が渡された場合、何もしません。
* {@primary This method does nothing if null array input.}
null を許容します
* {@primary the array to reverse, may be null}
*/
public static void reverse(final boolean[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
boolean tmp;
while (j > i) {
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
j--;
i++;
}
}
// IndexOf search
// ----------------------------------------------------------------------
// Object IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定されたオブジェクトを探し、そのインデックスを返します。 * {@primary Find the index of the given object in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param objectToFind 検索するオブジェクト、null を許容します
* {@primary the object to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the object within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final Object[] array, final Object objectToFind) {
return indexOf(array, objectToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定されたオブジェクトを探し、そのインデックスを返します。 * {@primary Find the index of the given object in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param objectToFind 検索するオブジェクト、null を許容します
* {@primary the object to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the object within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final Object[] array, final Object objectToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
if (objectToFind == null) {
for (int i = startIndex; i < array.length; i++) {
if (array[i] == null) {
return i;
}
}
} else {
for (int i = startIndex; i < array.length; i++) {
if (objectToFind.equals(array[i])) {
return i;
}
}
}
return -1;
}
/**
* 配列の後ろから順に指定されたオブジェクトを探し、そのインデックスを返します。 * {@primary Find the last index of the given object within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param objectToFind 検索するオブジェクト、null を許容します
* {@primary the object to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final Object[] array, final Object objectToFind) {
return lastIndexOf(array, objectToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定されたオブジェクトを探し、そのインデックスを返します。 * {@primary Find the last index of the given object in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array オブジェクトを後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param objectToFind 検索するオブジェクト、null を許容します
* {@primary the object to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final Object[] array, final Object objectToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
if (objectToFind == null) {
for (int i = startIndex; i >= 0; i--) {
if (array[i] == null) {
return i;
}
}
} else {
for (int i = startIndex; i >= 0; i--) {
if (objectToFind.equals(array[i])) {
return i;
}
}
}
return -1;
}
/**
* 指定されたオブジェクトがこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the object is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final Object[] array, final Object objectToFind) {
return (indexOf(array, objectToFind) != -1);
}
// long IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final long[] array, final long valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final long[] array, final long valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final long[] array, final long valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final long[] array, final long valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final long[] array, final long valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// int IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final int[] array, final int valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final int[] array, final int valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final int[] array, final int valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final int[] array, final int valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final int[] array, final int valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// short IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final short[] array, final short valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final short[] array, final short valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final short[] array, final short valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final short[] array, final short valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final short[] array, final short valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// byte IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final byte[] array, final byte valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final byte[] array, final byte valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final byte[] array, final byte valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final byte[] array, final byte valueToFind, int startIndex) {
if (array == null) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final byte[] array, final byte valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// double IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final double[] array, final double valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中から指定された値と指定された誤差に該当するものを探し、そのインデックスを返します。 * このメソッドは最初に見つかった valueToFind - tolerance と valueToFind + tolerance * の範囲に該当する値のインデックスを返します。 * {@primary Find the index of the given value within a given tolerance in the array. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値
* {@primary the value to find}
* @param tolerance 検索時の誤差
* {@primary tolerance of the search}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final double[] array, final double valueToFind, final double tolerance) {
return indexOf(array, valueToFind, 0, tolerance);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final double[] array, final double valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値と指定された誤差に該当するものを探し、そのインデックスを返します。 * このメソッドは最初に見つかった valueToFind - tolerance と valueToFind + tolerance * の範囲に該当する値のインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値
* {@primary the value to find}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @param tolerance 検索時の誤差
* {@primary tolerance of the search}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final double[] array, final double valueToFind, int startIndex, double tolerance) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
double min = valueToFind - tolerance;
double max = valueToFind + tolerance;
for (int i = startIndex; i < array.length; i++) {
if (array[i] >= min && array[i] <= max) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final double[] array, final double valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の後ろから順に指定された値と指定された誤差に該当するものを探し、そのインデックスを返します。 * このメソッドは最後に見つかった valueToFind - tolerance と valueToFind + tolerance * の範囲に該当する値のインデックスを返します。 * {@primary Find the last index of the given value within a given tolerance in the array. * This method will return the index of the last value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値
* {@primary the value to find}
* @param tolerance 検索時の誤差
* {@primary tolerance of the search}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final double[] array, final double valueToFind, final double tolerance) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final double[] array, final double valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値と指定された誤差に該当するものを探し、そのインデックスを返します。 * このメソッドは最後に見つかった valueToFind - tolerance と valueToFind + tolerance * の範囲に該当する値のインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index. * This method will return the index of the last value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値
* {@primary the value to find}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @param tolerance 検索対象の+/-の誤差の値
* {@primary search for value within plus/minus this amount}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final double[] array, final double valueToFind, int startIndex, double tolerance) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
double min = valueToFind - tolerance;
double max = valueToFind + tolerance;
for (int i = startIndex; i >= 0; i--) {
if (array[i] >= min && array[i] <= max) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final double[] array, final double valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
/**
* 指定された値と指定された誤差に該当する値がこの配列内に含まれているかどうかチェックします。
* 配列が (value - tolerance) から (value + tolerance) の範囲に該当する値を含んでいた場合
* true を返します。
* {@primary Checks if a value falling within the given tolerance is in the
* given array. If the array contains a value within the inclusive range
* defined by (value - tolerance) to (value + tolerance).}
null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if value falling within tolerance is in array}
*/
public static boolean contains(final double[] array, final double valueToFind, final double tolerance) {
return (indexOf(array, valueToFind, 0, tolerance) != -1);
}
// float IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final float[] array, final float valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final float[] array, final float valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final float[] array, final float valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final float[] array, final float valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final float[] array, final float valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// boolean IndexOf
//-----------------------------------------------------------------------
/**
* 配列の中から指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given valie in the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final boolean[] array, final boolean valueToFind) {
return indexOf(array, valueToFind, 0);
}
/**
* 配列の中の指定されたインデックスより後ろから指定された値を探し、そのインデックスを返します。 * {@primary Find the index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex の値は0とみなされます。
* startIndex が配列の長さより大きい場合には -1 が返されます。
* {@primary A negative startIndex is treated as zero. A startIndex larger than the array
* length will return -1.}
null を許容します
* {@primary the array to search through for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 検索を開始するインデックス
* {@primary the index to start searching at}
* @return 配列中の値のインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the index of the valie within the array,
* -1 if not found or null array input}
*/
public static int indexOf(final boolean[] array, final boolean valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
startIndex = 0;
}
for (int i = startIndex; i < array.length; i++) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 配列の後ろから順に指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value within the array.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the valie within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final boolean[] array, final boolean valueToFind) {
return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
}
/**
* 配列の中の指定されたインデックスから前方に向かって指定された値を探し、そのインデックスを返します。 * {@primary Find the last index of the given value in the array starting at the given index.}
* *このメソッドは null の配列が指定された場合 -1 を返します。
* {@primary This method returns -1 if null array input.}
マイナスの startIndex が指定された場合には -1 を返します。 * startIndex が配列の長さより大きい場合には配列の一番後ろからの検索を行います。 * {@primary A negative startIndex will return -1. A startIndex larger than the array * length will search from the end of the array.}
* * @param array 値を後ろから順に検索する対象となる配列、null を許容します
* {@primary the array to travers backwords looking for the object, may be null}
* @param valueToFind 検索する値、null を許容します
* {@primary the valie to find, may be null}
* @param startIndex 後ろから前への検索を開始するインデックス
* {@primary the start index to travers backwards from}
* @return 配列中のオブジェクトのインデックス、見つからなかった場合、配列が
* null だった場合には -1
* {@primary the last index of the object within the array,
* -1 if not found or null array input}
*/
public static int lastIndexOf(final boolean[] array, final boolean valueToFind, int startIndex) {
if (array == null || array.length == 0) {
return -1;
}
if (startIndex < 0) {
return -1;
} else if (startIndex >= array.length) {
startIndex = array.length - 1;
}
for (int i = startIndex; i >= 0; i--) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
/**
* 指定された値がこの配列内に含まれているかどうかチェックします。 * {@primary Checks if the value is in the given array.}
* *null の配列が指定された場合、このメソッドは false を返します。
* {@primary The method returns false if a null array is passed in.}
true
* {@primary true if the array contains the object}
*/
public static boolean contains(final boolean[] array, final boolean valueToFind) {
return (indexOf(array, valueToFind) != -1);
}
// Primitive/Object array converters
// ----------------------------------------------------------------------
// Long array converters
// ----------------------------------------------------------------------
/**
* Long オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Longs to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Long の配列、null を許容します
* {@primary a Long array, may be null}
* @return long の配列、null の配列が指定された場合 null
* {@primary a long array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static long[] toPrimitive(final Long[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_ARRAY;
}
final long[] result = new long[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].longValue();
}
return result;
}
/**
* Long オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Long to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Long の配列、null を許容します
* {@primary a Long array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return long の配列、null の配列が指定された場合 null
* {@primary a long array, null if null array input}
*/
public static long[] toPrimitive(final Long[] array, final long valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_ARRAY;
}
final long[] result = new long[array.length];
for (int i = 0; i < array.length; i++) {
Long b = array[i];
result[i] = (b == null ? valueForNull : b.longValue());
}
return result;
}
/**
* ling プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive longs to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
long の配列
* {@primary a long array}
* @return Long の配列、null の配列が指定された場合 null
* {@primary a Long array, null if null array input}
*/
public static Long[] toObject(final long[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_OBJECT_ARRAY;
}
final Long[] result = new Long[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Long(array[i]);
}
return result;
}
// Int array converters
// ----------------------------------------------------------------------
/**
* Integer オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Integers to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Integer の配列、null を許容します
* {@primary an Integer array, may be null}
* @return int の配列、null の配列が指定された場合 null
* {@primary an int array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static int[] toPrimitive(final Integer[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INT_ARRAY;
}
final int[] result = new int[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].intValue();
}
return result;
}
/**
* Integer オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Integer to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Integer の配列、null を許容します
* {@primary a Integer array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return int の配列、null の配列が指定された場合 null
* {@primary an int array, null if null array input}
*/
public static int[] toPrimitive(final Integer[] array, final int valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INT_ARRAY;
}
final int[] result = new int[array.length];
for (int i = 0; i < array.length; i++) {
Integer b = array[i];
result[i] = (b == null ? valueForNull : b.intValue());
}
return result;
}
/**
* int プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive ints to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
int の配列
* {@primary a int array}
* @return Integer の配列、null の配列が指定された場合 null
* {@primary a Integer array, null if null array input}
*/
public static Integer[] toObject(final int[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INTEGER_OBJECT_ARRAY;
}
final Integer[] result = new Integer[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Integer(array[i]);
}
return result;
}
// Short array converters
// ----------------------------------------------------------------------
/**
* Short オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Shorts to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Short の配列、null を許容します
* {@primary a Short array, may be null}
* @return short の配列、null の配列が指定された場合 null
* {@primary a short array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static short[] toPrimitive(final Short[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_ARRAY;
}
final short[] result = new short[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].shortValue();
}
return result;
}
/**
* Short オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Short to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Short の配列、null を許容します
* {@primary a Short array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return short の配列、null の配列が指定された場合 null
* {@primary a short array, null if null array input}
*/
public static short[] toPrimitive(final Short[] array, final short valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_ARRAY;
}
final short[] result = new short[array.length];
for (int i = 0; i < array.length; i++) {
Short b = array[i];
result[i] = (b == null ? valueForNull : b.shortValue());
}
return result;
}
/**
* short プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive shorts to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
short の配列
* {@primary a short array}
* @return Short の配列、null の配列が指定された場合 null
* {@primary a Short array, null if null array input}
*/
public static Short[] toObject(final short[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_OBJECT_ARRAY;
}
final Short[] result = new Short[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Short(array[i]);
}
return result;
}
// Byte array converters
// ----------------------------------------------------------------------
/**
* Byte オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Bytes to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Byte の配列、null を許容します
* {@primary a Byte array, may be null}
* @return byte の配列、null の配列が指定された場合 null
* {@primary a byte array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static byte[] toPrimitive(final Byte[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_ARRAY;
}
final byte[] result = new byte[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].byteValue();
}
return result;
}
/**
* Byte オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Byte to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Byte の配列、null を許容します
* {@primary a Byte array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return byte の配列、null の配列が指定された場合 null
* {@primary a byte array, null if null array input}
*/
public static byte[] toPrimitive(final Byte[] array, final byte valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_ARRAY;
}
final byte[] result = new byte[array.length];
for (int i = 0; i < array.length; i++) {
Byte b = array[i];
result[i] = (b == null ? valueForNull : b.byteValue());
}
return result;
}
/**
* byte プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive bytes to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
byte の配列
* {@primary a byte array}
* @return Byte の配列、null の配列が指定された場合 null
* {@primary a Byte array, null if null array input}
*/
public static Byte[] toObject(final byte[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_OBJECT_ARRAY;
}
final Byte[] result = new Byte[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Byte(array[i]);
}
return result;
}
// Double array converters
// ----------------------------------------------------------------------
/**
* Double オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Doubles to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Double の配列、null を許容します
* {@primary a Double array, may be null}
* @return double の配列、null の配列が指定された場合 null
* {@primary a double array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static double[] toPrimitive(final Double[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_ARRAY;
}
final double[] result = new double[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].doubleValue();
}
return result;
}
/**
* Double オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Doubles to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Double の配列、null を許容します
* {@primary a Double array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return double の配列、null の配列が指定された場合 null
* {@primary a double array, null if null array input}
*/
public static double[] toPrimitive(final Double[] array, final double valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_ARRAY;
}
final double[] result = new double[array.length];
for (int i = 0; i < array.length; i++) {
Double b = array[i];
result[i] = (b == null ? valueForNull : b.doubleValue());
}
return result;
}
/**
* double プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive doubles to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
double の配列
* {@primary a double array}
* @return Double の配列、null の配列が指定された場合 null
* {@primary a Double array, null if null array input}
*/
public static Double[] toObject(final double[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_OBJECT_ARRAY;
}
final Double[] result = new Double[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Double(array[i]);
}
return result;
}
// Float array converters
// ----------------------------------------------------------------------
/**
* Float オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Floats to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Float の配列、null を許容します
* {@primary a Float array, may be null}
* @return float の配列、null の配列が指定された場合 null
* {@primary a float array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static float[] toPrimitive(final Float[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_ARRAY;
}
final float[] result = new float[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].floatValue();
}
return result;
}
/**
* Float オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Floats to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Float の配列、null を許容します
* {@primary a Float array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return float の配列、null の配列が指定された場合 null
* {@primary a float array, null if null array input}
*/
public static float[] toPrimitive(final Float[] array, final float valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_ARRAY;
}
final float[] result = new float[array.length];
for (int i = 0; i < array.length; i++) {
Float b = array[i];
result[i] = (b == null ? valueForNull : b.floatValue());
}
return result;
}
/**
* float プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive floats to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
float の配列
* {@primary a float array}
* @return Float の配列、null の配列が指定された場合 null
* {@primary a Float array, null if null array input}
*/
public static Float[] toObject(final float[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_OBJECT_ARRAY;
}
final Float[] result = new Float[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = new Float(array[i]);
}
return result;
}
// Boolean array converters
// ----------------------------------------------------------------------
/**
* Boolean オブジェクトの配列をプリミティブ型の配列に変換します。 * {@primary Converts an array of object Booleans to primitives.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Boolean の配列、null を許容します
* {@primary a Boolean array, may be null}
* @return boolean の配列、null の配列が指定された場合 null
* {@primary a boolean array, null if null array input}
* @throws NullPointerException 配列が nullの要素をもっていた場合
* {@primary if array content is null}
*/
public static boolean[] toPrimitive(final Boolean[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_ARRAY;
}
final boolean[] result = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].booleanValue();
}
return result;
}
/**
* Boolean オブジェクトの配列をプリミティブ型の配列に変換します(null の要素を処理します)。
* {@primary Converts an array of object Booleans to primitives handling null.}
このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
Boolean の配列、null を許容します
* {@primary a Boolean array, may be null}
* @param valueForNull null が見つかった場合に適用する値
* {@primary the value to insert if null found}
* @return boolean の配列、null の配列が指定された場合 null
* {@primary a boolean array, null if null array input}
*/
public static boolean[] toPrimitive(final Boolean[] array, final boolean valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_ARRAY;
}
final boolean[] result = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
Boolean b = array[i];
result[i] = (b == null ? valueForNull : b.booleanValue());
}
return result;
}
/**
* boolean プリミティブ型の配列をオブジェクトの配列に変換します。 * {@primary Converts an array of primitive booleans to objects.}
* *このメソッドは null の配列が指定された場合 null を返します。
* {@primary This method returns null if null array input.}
boolean の配列
* {@primary a boolean array}
* @return Boolean の配列、null の配列が指定された場合 null
* {@primary a Boolean array, null if null array input}
*/
public static Boolean[] toObject(final boolean[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_OBJECT_ARRAY;
}
final Boolean[] result = new Boolean[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = (array[i] ? Boolean.TRUE : Boolean.FALSE);
}
return result;
}
}