```
public class Arrays
extends Object
```
このクラスには、ソートや検索など、配列を操作するためのさまざまなメソッドがあります。また、配列をリストとして表示するためのstaticファクトリもあります。
指定された配列参照がnullの場合、それ以外の処理が明示されている場合を除き、このクラスのメソッドはすべてNullPointerExceptionをスローします。
このクラスに含まれるメソッドのドキュメントには、implementationsの簡単な説明が含まれています。この説明は、仕様の一部ではなく実装ノートと考えてください。実装者は、仕様に反しないかぎり、ほかのアルゴリズムを自由に使用できます。たとえば、sort(Object[])が使用するアルゴリズムはマージ・ソートである必要はありませんが、固定(stable)のアルゴリズムでなければいけません。
このクラスは、Java Collections Frameworkのメンバーです。

導入されたバージョン:

1.2

メソッドのサマリー

すべてのメソッド静的メソッド具象メソッド
修飾子と型	メソッド	説明
`static <T> List<T>`	`asList(T... a)`	指定された配列に連動する固定サイズのリストを返します。
`static int`	`binarySearch(byte[] a, byte key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値を検索します。
`static int`	`binarySearch(byte[] a, int fromIndex, int toIndex, byte key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(char[] a, char key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値を検索します。
`static int`	`binarySearch(char[] a, int fromIndex, int toIndex, char key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(double[] a, double key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値を検索します。
`static int`	`binarySearch(double[] a, int fromIndex, int toIndex, double key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(float[] a, float key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値を検索します。
`static int`	`binarySearch(float[] a, int fromIndex, int toIndex, float key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(int[] a, int key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値を検索します。
`static int`	`binarySearch(int[] a, int fromIndex, int toIndex, int key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(long[] a, int fromIndex, int toIndex, long key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(long[] a, long key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値を検索します。
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)`	バイナリ・サーチ・アルゴリズムを使用して、指定されたshort値の配列から指定された値の範囲を検索します。
`static int`	`binarySearch(short[] a, short key)`	バイナリ・サーチ・アルゴリズムを使用し、指定されたshort値の配列から指定された値を検索します。
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)`	バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。
`static int`	`binarySearch(Object[] a, Object key)`	バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。
`static <T> int`	`binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)`	バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。
`static <T> int`	`binarySearch(T[] a, T key, Comparator<? super T> c)`	バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。
`static int`	`compare(boolean[] a, boolean[] b)`	2つの`boolean`配列を辞書順に比較します。
`static int`	`compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`boolean`配列を辞書順に比較します。
`static int`	`compare(byte[] a, byte[] b)`	2つの`byte`配列を辞書順に比較します。
`static int`	`compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`byte`配列を辞書順に比較します。
`static int`	`compare(char[] a, char[] b)`	2つの`char`配列を辞書順に比較します。
`static int`	`compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`char`配列を辞書順に比較します。
`static int`	`compare(double[] a, double[] b)`	2つの`double`配列を辞書順に比較します。
`static int`	`compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`double`配列を辞書順に比較します。
`static int`	`compare(float[] a, float[] b)`	2つの`float`配列を辞書順に比較します。
`static int`	`compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`float`配列を辞書順に比較します。
`static int`	`compare(int[] a, int[] b)`	2つの`int`配列を辞書順に比較します。
`static int`	`compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`int`配列を辞書順に比較します。
`static int`	`compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`long`配列を辞書順に比較します。
`static int`	`compare(long[] a, long[] b)`	2つの`long`配列を辞書順に比較します。
`static int`	`compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`short`配列を辞書順に比較します。
`static int`	`compare(short[] a, short[] b)`	2つの`short`配列を辞書順に比較します。
`static <T extends Comparable<? super T>> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)`	指定された範囲にわたって2つの`Object`配列を辞書順に比較します。
`static <T> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	指定された範囲にわたって2つの`Object`配列を辞書順に比較します。
`static <T extends Comparable<? super T>> int`	`compare(T[] a, T[] b)`	比較可能な要素内の2つの`Object`配列を辞書順に比較します。
`static <T> int`	`compare(T[] a, T[] b, Comparator<? super T> cmp)`	指定されたコンパレータを使用して、2つの`Object`配列を辞書順に比較します。
`static int`	`compareUnsigned(byte[] a, byte[] b)`	2つの`byte`配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
`static int`	`compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	2つの`byte`配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
`static int`	`compareUnsigned(int[] a, int[] b)`	2つの`int`配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
`static int`	`compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	2つの`int`配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
`static int`	`compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	2つの`long`配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
`static int`	`compareUnsigned(long[] a, long[] b)`	2つの`long`配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
`static int`	`compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	2つの`short`配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
`static int`	`compareUnsigned(short[] a, short[] b)`	2つの`short`配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
`static boolean[]`	`copyOf(boolean[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるか`false`でパディングします。
`static byte[]`	`copyOf(byte[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static char[]`	`copyOf(char[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnull文字でパディングします。
`static double[]`	`copyOf(double[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static float[]`	`copyOf(float[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static int[]`	`copyOf(int[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static long[]`	`copyOf(long[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static short[]`	`copyOf(short[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。
`static <T> T[]`	`copyOf(T[] original, int newLength)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。
`static <T,U> T[]`	`copyOf(U[] original, int newLength, Class<? extends T[]> newType)`	指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。
`static boolean[]`	`copyOfRange(boolean[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static byte[]`	`copyOfRange(byte[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static char[]`	`copyOfRange(char[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static double[]`	`copyOfRange(double[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static float[]`	`copyOfRange(float[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static int[]`	`copyOfRange(int[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static long[]`	`copyOfRange(long[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static short[]`	`copyOfRange(short[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static <T> T[]`	`copyOfRange(T[] original, int from, int to)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static <T,U> T[]`	`copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)`	指定された配列の指定された範囲を新しい配列にコピーします。
`static boolean`	`deepEquals(Object[] a1, Object[] a2)`	2つの指定された配列が相互に深層で等価な場合、`true`を返します。
`static int`	`deepHashCode(Object[] a)`	指定された配列の「深層内容」に基づくハッシュ・コードを返します。
`static String`	`deepToString(Object[] a)`	指定された配列の「深層内容」の文字列表現を返します。
`static boolean`	`equals(boolean[] a, boolean[] a2)`	指定された2つのboolean値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	ブール値の指定された2つの配列が、指定された範囲にわたって、互いにequalの場合にtrueを返します。
`static boolean`	`equals(byte[] a, byte[] a2)`	指定された2つのbyte値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	指定された2つのバイトの配列が、指定された範囲で互いにequalの場合にtrueを返します。
`static boolean`	`equals(char[] a, char[] a2)`	指定された2つのchar値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	指定された2つの文字配列が、指定された範囲にわたってequalである場合にtrueを返します。
`static boolean`	`equals(double[] a, double[] a2)`	指定された2つのdouble値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	指定された範囲のdoubleの2つの指定された配列が互いにequalの場合にtrueを返します。
`static boolean`	`equals(float[] a, float[] a2)`	指定された2つのfloat値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	floatの指定された2つの配列が、指定された範囲にわたって、互いにequalである場合にtrueを返します。
`static boolean`	`equals(int[] a, int[] a2)`	指定された2つのint値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	指定された範囲のintの2つの指定された配列が互いにequalである場合にtrueを返します。
`static boolean`	`equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	指定された範囲の2つの指定されたlong配列が互いにequalの場合にtrueを返します。
`static boolean`	`equals(long[] a, long[] a2)`	指定された2つのlong値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	指定された2つのshortの配列が、指定された範囲で互いにequalの場合にtrueを返します。
`static boolean`	`equals(short[] a, short[] a2)`	指定された2つのshort値の配列が互いに同等である場合に`true`を返します。
`static boolean`	`equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。
`static boolean`	`equals(Object[] a, Object[] a2)`	指定された2つのObjectの配列が互いに同等である場合に`true`を返します。
`static <T> boolean`	`equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。
`static <T> boolean`	`equals(T[] a, T[] a2, Comparator<? super T> cmp)`	指定された2つのObjectの配列が互いに同等である場合に`true`を返します。
`static void`	`fill(boolean[] a, boolean val)`	指定されたboolean値の配列の各要素に、指定されたboolean値を代入します。
`static void`	`fill(boolean[] a, int fromIndex, int toIndex, boolean val)`	boolean値で指定された配列の中で、指定された範囲にある各要素に、指定されたboolean値を割り当てます。
`static void`	`fill(byte[] a, byte val)`	指定されたbyte値の配列の各要素に、指定されたbyte値を代入します。
`static void`	`fill(byte[] a, int fromIndex, int toIndex, byte val)`	byte値で指定された配列の中で、指定された範囲にある各要素に、指定されたbyte値を割り当てます。
`static void`	`fill(char[] a, char val)`	指定されたchar値の配列の各要素に、指定されたchar値を代入します。
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)`	char値で指定された配列の中で、指定された範囲にある各要素に、指定されたchar値を割り当てます。
`static void`	`fill(double[] a, double val)`	指定されたdouble値の配列の各要素に、指定されたdouble値を代入します。
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)`	double値で指定された配列の中で、指定された範囲にある各要素に、指定されたdouble値を割り当てます。
`static void`	`fill(float[] a, float val)`	指定されたfloat値の配列の各要素に、指定されたfloat値を代入します。
`static void`	`fill(float[] a, int fromIndex, int toIndex, float val)`	float値で指定された配列の中で、指定された範囲にある各要素に、指定されたfloat値を割り当てます。
`static void`	`fill(int[] a, int val)`	指定されたint値の配列の各要素に、指定されたint値を代入します。
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)`	int値で指定された配列の中で、指定された範囲にある各要素に、指定されたint値を割り当てます。
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)`	long値で指定された配列の中で、指定された範囲にある各要素に、指定されたlong値を割り当てます。
`static void`	`fill(long[] a, long val)`	指定されたlong値の配列の各要素に、指定されたlong値を代入します。
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)`	short値で指定された配列の中で、指定された範囲にある各要素に、指定されたshort値を割り当てます。
`static void`	`fill(short[] a, short val)`	指定されたshort値の配列の各要素に、指定されたshort値を代入します。
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)`	指定されたObjectの配列で、指定された範囲にある各要素に、指定されたObject参照を代入します。
`static void`	`fill(Object[] a, Object val)`	指定されたObjectの配列の各要素に、指定されたObject参照を代入します。
`static int`	`hashCode(boolean[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(byte[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(char[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(double[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(float[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(int[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(long[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(short[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`hashCode(Object[] a)`	指定された配列の内容に基づくハッシュ・コードを返します。
`static int`	`mismatch(boolean[] a, boolean[] b)`	2つの`boolean`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	2つの`boolean`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(byte[] a, byte[] b)`	2つの`byte`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	2つの`byte`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(char[] a, char[] b)`	2つの`char`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	2つの`char`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(double[] a, double[] b)`	2つの`double`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	2つの`double`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(float[] a, float[] b)`	2つの`float`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	2つの`float`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(int[] a, int[] b)`	2つの`int`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	2つの`int`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	2つの`long`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(long[] a, long[] b)`	2つの`long`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	2つの`short`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(short[] a, short[] b)`	2つの`short`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static int`	`mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	2つの`Object`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static int`	`mismatch(Object[] a, Object[] b)`	2つの`Object`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static <T> int`	`mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	2つの`Object`配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。
`static <T> int`	`mismatch(T[] a, T[] b, Comparator<? super T> cmp)`	2つの`Object`配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。
`static void`	`parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)`	配列の指定された部分範囲に対して`parallelPrefix(double[], DoubleBinaryOperator)`を実行します。
`static void`	`parallelPrefix(double[] array, DoubleBinaryOperator op)`	指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。
`static void`	`parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)`	配列の指定された部分範囲に対して`parallelPrefix(int[], IntBinaryOperator)`を実行します。
`static void`	`parallelPrefix(int[] array, IntBinaryOperator op)`	指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。
`static void`	`parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)`	配列の指定された部分範囲に対して`parallelPrefix(long[], LongBinaryOperator)`を実行します。
`static void`	`parallelPrefix(long[] array, LongBinaryOperator op)`	指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。
`static <T> void`	`parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)`	配列の指定された部分範囲に対して`parallelPrefix(Object[], BinaryOperator)`を実行します。
`static <T> void`	`parallelPrefix(T[] array, BinaryOperator<T> op)`	指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。
`static void`	`parallelSetAll(double[] array, IntToDoubleFunction generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
`static void`	`parallelSetAll(int[] array, IntUnaryOperator generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
`static void`	`parallelSetAll(long[] array, IntToLongFunction generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
`static <T> void`	`parallelSetAll(T[] array, IntFunction<? extends T> generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
`static void`	`parallelSort(byte[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(byte[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(char[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(char[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(double[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(double[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(float[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(float[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(int[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(int[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(long[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(long[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static void`	`parallelSort(short[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`parallelSort(short[] a, int fromIndex, int toIndex)`	配列の指定された範囲を数値の昇順でソートします。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a)`	指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a, int fromIndex, int toIndex)`	指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。
`static <T> void`	`parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)`	指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。
`static <T> void`	`parallelSort(T[] a, Comparator<? super T> cmp)`	指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。
`static void`	`setAll(double[] array, IntToDoubleFunction generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
`static void`	`setAll(int[] array, IntUnaryOperator generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
`static void`	`setAll(long[] array, IntToLongFunction generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
`static <T> void`	`setAll(T[] array, IntFunction<? extends T> generator)`	指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
`static void`	`sort(byte[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(byte[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(char[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(char[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(double[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(double[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(float[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(float[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(int[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(int[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(long[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(long[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(short[] a)`	指定された配列を数値の昇順でソートします。
`static void`	`sort(short[] a, int fromIndex, int toIndex)`	指定された範囲の配列を昇順にソートします。
`static void`	`sort(Object[] a)`	指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。
`static void`	`sort(Object[] a, int fromIndex, int toIndex)`	指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)`	指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。
`static <T> void`	`sort(T[] a, Comparator<? super T> c)`	指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。
`static Spliterator.OfDouble`	`spliterator(double[] array)`	指定された配列のすべてに適用される`Spliterator.OfDouble`を返します。
`static Spliterator.OfDouble`	`spliterator(double[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲に適用される`Spliterator.OfDouble`を返します。
`static Spliterator.OfInt`	`spliterator(int[] array)`	指定された配列のすべてに適用される`Spliterator.OfInt`を返します。
`static Spliterator.OfInt`	`spliterator(int[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲に適用される`Spliterator.OfInt`を返します。
`static Spliterator.OfLong`	`spliterator(long[] array)`	指定された配列のすべてに適用される`Spliterator.OfLong`を返します。
`static Spliterator.OfLong`	`spliterator(long[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲に適用される`Spliterator.OfLong`を返します。
`static <T> Spliterator<T>`	`spliterator(T[] array)`	指定された配列のすべてに適用される`Spliterator`を返します。
`static <T> Spliterator<T>`	`spliterator(T[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲に適用される`Spliterator`を返します。
`static DoubleStream`	`stream(double[] array)`	指定された配列をソースとして使用して、逐次的な`DoubleStream`を返します。
`static DoubleStream`	`stream(double[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲をソースとして使用して、逐次的な`DoubleStream`を返します。
`static IntStream`	`stream(int[] array)`	指定された配列をソースとして使用して、逐次的な`IntStream`を返します。
`static IntStream`	`stream(int[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲をソースとして使用して、逐次的な`IntStream`を返します。
`static LongStream`	`stream(long[] array)`	指定された配列をソースとして使用して、逐次的な`LongStream`を返します。
`static LongStream`	`stream(long[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲をソースとして使用して、逐次的な`LongStream`を返します。
`static <T> Stream<T>`	`stream(T[] array)`	指定された配列をソースとして使用して、逐次的な`Stream`を返します。
`static <T> Stream<T>`	`stream(T[] array, int startInclusive, int endExclusive)`	指定された配列の指定された範囲をソースとして使用して、逐次的な`Stream`を返します。
`static String`	`toString(boolean[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(byte[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(char[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(double[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(float[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(int[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(long[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(short[] a)`	指定された配列の文字列表現を返します。
`static String`	`toString(Object[] a)`	指定された配列の文字列表現を返します。

クラス java.lang.Objectで宣言されたメソッド
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- メソッドの詳細
  - sort
```
public static void sort(int[] a)
```
    指定された配列を数値の昇順でソートします。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(long[] a)
```
    指定された配列を数値の昇順でソートします。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(short[] a)
```
    指定された配列を数値の昇順でソートします。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(char[] a)
```
    指定された配列を数値の昇順でソートします。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(byte[] a)
```
    指定された配列を数値の昇順でソートします。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(float[] a)
```
    指定された配列を数値の昇順でソートします。
    <のリレーションは、すべての浮動小数点値に関する全体順序付けを提供しません。つまり、-0.0f == 0.0fはtrueであり、Float.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Float.compareTo(java.lang.Float)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0fは値0.0f未満として扱われ、Float.NaNは他のどの値よりも大きいと見なされ、すべてのFloat.NaN値は等価と見なされます。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    <のリレーションは、すべての浮動小数点値に関する全体順序付けを提供しません。つまり、-0.0f == 0.0fはtrueであり、Float.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Float.compareTo(java.lang.Float)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0fは値0.0f未満として扱われ、Float.NaNは他のどの値よりも大きいと見なされ、すべてのFloat.NaN値は等価と見なされます。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - sort
```
public static void sort(double[] a)
```
    指定された配列を数値の昇順でソートします。
    <のリレーションは、すべてのdouble値に関する全体順序付けを提供しません。つまり、-0.0d == 0.0dはtrueであり、Double.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Double.compareTo(java.lang.Double)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0dは値0.0d未満として扱われ、Double.NaNは他のどの値よりも大きいと見なされ、すべてのDouble.NaN値は等価と見なされます。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
  - sort
```
public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)
```
    指定された範囲の配列を昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    <のリレーションは、すべてのdouble値に関する全体順序付けを提供しません。つまり、-0.0d == 0.0dはtrueであり、Double.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Double.compareTo(java.lang.Double)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0dは値0.0d未満として扱われ、Double.NaNは他のどの値よりも大きいと見なされ、すべてのDouble.NaN値は等価と見なされます。
    実装にあたってのノート: ソート・アルゴリズムは、Vladimir Yaroslavskiy氏、Jon Bentley氏、およびJoshua Bloch氏によるDual-Pivot Quicksortです。このアルゴリズムは、ほかのクイックソート・アルゴリズムではnの2乗のパフォーマンスに低下させる多くのデータ・セットで、O(n log(n))のパフォーマンスを提供し、一般的に従来の(1ピボットの) Quicksortの実装よりも高速です。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - parallelSort
```
public static void parallelSort(byte[] a)
```
    指定された配列を数値の昇順でソートします。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(byte[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a)
```
    指定された配列を数値の昇順でソートします。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a)
```
    指定された配列を数値の昇順でソートします。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a)
```
    指定された配列を数値の昇順でソートします。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a)
```
    指定された配列を数値の昇順でソートします。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a)
```
    指定された配列を数値の昇順でソートします。
    <のリレーションは、すべての浮動小数点値に関する全体順序付けを提供しません。つまり、-0.0f == 0.0fはtrueであり、Float.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Float.compareTo(java.lang.Float)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0fは値0.0f未満として扱われ、Float.NaNは他のどの値よりも大きいと見なされ、すべてのFloat.NaN値は等価と見なされます。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    <のリレーションは、すべての浮動小数点値に関する全体順序付けを提供しません。つまり、-0.0f == 0.0fはtrueであり、Float.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Float.compareTo(java.lang.Float)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0fは値0.0f未満として扱われ、Float.NaNは他のどの値よりも大きいと見なされ、すべてのFloat.NaN値は等価と見なされます。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a)
```
    指定された配列を数値の昇順でソートします。
    <のリレーションは、すべてのdouble値に関する全体順序付けを提供しません。つまり、-0.0d == 0.0dはtrueであり、Double.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Double.compareTo(java.lang.Double)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0dは値0.0d未満として扱われ、Double.NaNは他のどの値よりも大きいと見なされ、すべてのDouble.NaN値は等価と見なされます。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a,
                                int fromIndex,
                                int toIndex)
```
    配列の指定された範囲を数値の昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
    <のリレーションは、すべてのdouble値に関する全体順序付けを提供しません。つまり、-0.0d == 0.0dはtrueであり、Double.NaN値はあらゆる値やそれ自体と比較しても、それ以下でも以上でも等値でもありません。このメソッドは、Double.compareTo(java.lang.Double)メソッドによって課せられる全体順序付けを使用します。つまり、-0.0dは値0.0d未満として扱われ、Double.NaNは他のどの値よりも大きいと見なされ、すべてのDouble.NaN値は等価と見なされます。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
```
    指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。配列のすべての要素は、Comparableインタフェースを実装する必要があります。また、配列のすべての要素は、相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、e1.compareTo(e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    例外:
    
    ClassCastException - 配列に相互に比較可能でない要素(たとえば、文字列と整数)がある場合
    
    IllegalArgumentException - (オプション)配列要素の自然順序付けがComparableの規約に違反していることが検出された場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a,
                                                                  int fromIndex,
                                                                  int toIndex)
```
    指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、ソート範囲は空になります。この範囲のすべての要素は、Comparableインタフェースを実装する必要があります。また、この範囲のすべての要素は、相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、e1.compareTo(e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合、または配列要素の自然順序付けがComparableの規約に違反していることが検出された場合(オプション)
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    ClassCastException - 配列に相互に比較可能でない要素(たとえば、文字列と整数)がある場合。
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    Comparator<? super T> cmp)
```
    指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。配列のすべての要素は、指定されたコンパレータで相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、c.compare(e1, e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    cmp - 配列の順序を決定するコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    例外:
    
    ClassCastException - 配列に、指定されたコンパレータで相互に比較できない要素がある場合
    
    IllegalArgumentException - (オプション)コンパレータがComparatorの規約に違反していることが検出された場合
    
    導入されたバージョン:
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    int fromIndex,
                                    int toIndex,
                                    Comparator<? super T> cmp)
```
    指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、ソート範囲は空になります。範囲のすべての要素は、指定されたコンパレータで相互に比較可能でなければいけません。つまり、範囲の要素がe1およびe2の場合に、c.compare(e1, e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    
    実装上のノート:
    
    このソート・アルゴリズムとは、配列を部分配列に分割し、それらの部分配列自身がソートされた後でマージされるという並列ソート・マージです。部分配列の長さが最小精度に達すると、その部分配列は適切なArrays.sortメソッドを使ってソートされます。指定された配列の長さが最小精度未満である場合は、適切なArrays.sortメソッドを使ってソートされます。このアルゴリズムでは、元の配列の指定された範囲のサイズと同じぐらいの作業スペースが必要です。並列タスクの実行には、ForkJoin common poolが使用されます。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    cmp - 配列の順序を決定するコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合、または配列要素の自然順序付けがComparableの規約に違反していることが検出された場合(オプション)
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    ClassCastException - 配列に相互に比較可能でない要素(たとえば、文字列と整数)がある場合。
    
    導入されたバージョン:
    
    1.8
  - sort
```
public static void sort(Object[] a)
```
    指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。配列のすべての要素は、Comparableインタフェースを実装する必要があります。また、配列のすべての要素は、相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、e1.compareTo(e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    実装にあたってのノート:この実装は安定した適応型の反復マージ・ソートです。このソートでは、入力配列がランダムに順序付けられる場合は従来のマージ・ソートのパフォーマンスを提供しながら、入力配列が部分的にソートされている場合は必要となる比較回数がn lg(n)よりもかなり少なくなります。入力配列がほとんどソートされている場合、この実装ではおよそn回の比較が必要になります。一時ストレージの要件は、ほとんどソートされている入力配列用の小さな定数から、ランダムに順序付けられた入力配列用のn/2のオブジェクト参照までさまざまです。
    この実装では、その入力配列で昇順と降順を等しく利用するため、同じ入力配列のさまざまな部分で昇順と降順を利用できます。それは、2つ以上のソートされた配列をマージするのに適切です。つまり、それらの配列を連結し、結果となる配列をソートするだけです。
    この実装は、Tim Peters氏によるPython用のリスト・ソート(TimSort)から応用されました。それは、『Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms』(1993年1月)の467-474ページに記載されている、Peter McIlroy氏の「Optimistic Sorting and Information Theoretic Complexity」からの技術を採用しています。
    
    パラメータ:
    
    a - ソートされる配列
    
    例外:
    
    ClassCastException - 配列に相互に比較可能でない要素(たとえば、文字列と整数)がある場合
    
    IllegalArgumentException - (オプション)配列要素の自然順序付けがComparableの規約に違反していることが検出された場合
  - sort
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)
```
    指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、ソート範囲は空になります。この範囲のすべての要素は、Comparableインタフェースを実装する必要があります。また、この範囲のすべての要素は、相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、e1.compareTo(e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    実装にあたってのノート:この実装は安定した適応型の反復マージ・ソートです。このソートでは、入力配列がランダムに順序付けられる場合は従来のマージ・ソートのパフォーマンスを提供しながら、入力配列が部分的にソートされている場合は必要となる比較回数がn lg(n)よりもかなり少なくなります。入力配列がほとんどソートされている場合、この実装ではおよそn回の比較が必要になります。一時ストレージの要件は、ほとんどソートされている入力配列用の小さな定数から、ランダムに順序付けられた入力配列用のn/2のオブジェクト参照までさまざまです。
    この実装では、その入力配列で昇順と降順を等しく利用するため、同じ入力配列のさまざまな部分で昇順と降順を利用できます。それは、2つ以上のソートされた配列をマージするのに適切です。つまり、それらの配列を連結し、結果となる配列をソートするだけです。
    この実装は、Tim Peters氏によるPython用のリスト・ソート(TimSort)から応用されました。それは、『Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms』(1993年1月)の467-474ページに記載されている、Peter McIlroy氏の「Optimistic Sorting and Information Theoretic Complexity」からの技術を採用しています。
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合、または配列要素の自然順序付けがComparableの規約に違反していることが検出された場合(オプション)
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    ClassCastException - 配列に相互に比較可能でない要素(たとえば、文字列と整数)がある場合。
  - sort
```
public static <T> void sort(T[] a,
                            Comparator<? super T> c)
```
    指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。配列のすべての要素は、指定されたコンパレータで相互に比較可能でなければいけません。つまり、配列の要素がe1およびe2の場合に、c.compare(e1, e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    実装にあたってのノート:この実装は安定した適応型の反復マージ・ソートです。このソートでは、入力配列がランダムに順序付けられる場合は従来のマージ・ソートのパフォーマンスを提供しながら、入力配列が部分的にソートされている場合は必要となる比較回数がn lg(n)よりもかなり少なくなります。入力配列がほとんどソートされている場合、この実装ではおよそn回の比較が必要になります。一時ストレージの要件は、ほとんどソートされている入力配列用の小さな定数から、ランダムに順序付けられた入力配列用のn/2のオブジェクト参照までさまざまです。
    この実装では、その入力配列で昇順と降順を等しく利用するため、同じ入力配列のさまざまな部分で昇順と降順を利用できます。それは、2つ以上のソートされた配列をマージするのに適切です。つまり、それらの配列を連結し、結果となる配列をソートするだけです。
    この実装は、Tim Peters氏によるPython用のリスト・ソート(TimSort)から応用されました。それは、『Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms』(1993年1月)の467-474ページに記載されている、Peter McIlroy氏の「Optimistic Sorting and Information Theoretic Complexity」からの技術を採用しています。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    c - 配列の順序を決定するコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    例外:
    
    ClassCastException - 配列に、指定されたコンパレータで相互に比較できない要素がある場合
    
    IllegalArgumentException - (オプション)コンパレータがComparatorの規約に違反していることが検出された場合
  - sort
```
public static <T> void sort(T[] a,
                            int fromIndex,
                            int toIndex,
                            Comparator<? super T> c)
```
    指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、ソート範囲は空になります。範囲のすべての要素は、指定されたコンパレータで相互に比較可能でなければいけません。つまり、範囲の要素がe1およびe2の場合に、c.compare(e1, e2)でClassCastExceptionをスローすべきではありません。
    このソートは固定であることが保証されています。つまり、ソートを実行しても、同等の要素の順序は変わりません。
    実装にあたってのノート:この実装は安定した適応型の反復マージ・ソートです。このソートでは、入力配列がランダムに順序付けられる場合は従来のマージ・ソートのパフォーマンスを提供しながら、入力配列が部分的にソートされている場合は必要となる比較回数がn lg(n)よりもかなり少なくなります。入力配列がほとんどソートされている場合、この実装ではおよそn回の比較が必要になります。一時ストレージの要件は、ほとんどソートされている入力配列用の小さな定数から、ランダムに順序付けられた入力配列用のn/2のオブジェクト参照までさまざまです。
    この実装では、その入力配列で昇順と降順を等しく利用するため、同じ入力配列のさまざまな部分で昇順と降順を利用できます。それは、2つ以上のソートされた配列をマージするのに適切です。つまり、それらの配列を連結し、結果となる配列をソートするだけです。
    この実装は、Tim Peters氏によるPython用のリスト・ソート(TimSort)から応用されました。それは、『Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms』(1993年1月)の467-474ページに記載されている、Peter McIlroy氏の「Optimistic Sorting and Information Theoretic Complexity」からの技術を採用しています。
    
    型パラメータ:
    
    T - ソートされるオブジェクトのクラス
    
    パラメータ:
    
    a - ソートされる配列
    
    fromIndex - ソートされる最初の要素(これを含む)のインデックス
    
    toIndex - ソートされる最後の要素(これを含まない)のインデックス
    
    c - 配列の順序を決定するコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    例外:
    
    ClassCastException - 配列に、指定されたコンパレータで相互に比較できない要素がある場合。
    
    IllegalArgumentException - fromIndex> toIndexの場合、またはコンパレータがComparatorの規約に違反していることが検出された場合(オプション)
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - parallelPrefix
```
public static <T> void parallelPrefix(T[] array,
                                      BinaryOperator<T> op)
```
    指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。たとえば、配列に最初に[2, 1, 0, 3]が含まれているときに、その操作で加算が行われた場合、復帰時の配列には[2, 3, 3, 6]が含まれています。大きな配列の場合は通常、順次的なループ処理よりも並列的な前置演算の方が効率的です。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    array - このメソッドによってその場で変更される配列
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static <T> void parallelPrefix(T[] array,
                                      int fromIndex,
                                      int toIndex,
                                      BinaryOperator<T> op)
```
    配列の指定された部分範囲に対してparallelPrefix(Object[], BinaryOperator)を実行します。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    array - 配列
    
    fromIndex - 最初の要素のインデックス(これを含む)
    
    toIndex - 最後の要素のインデックス(これを含まない)
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex > array.lengthの場合
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  LongBinaryOperator op)
```
    指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。たとえば、配列に最初に[2, 1, 0, 3]が含まれているときに、その操作で加算が行われた場合、復帰時の配列には[2, 3, 3, 6]が含まれています。大きな配列の場合は通常、順次的なループ処理よりも並列的な前置演算の方が効率的です。
    
    パラメータ:
    
    array - このメソッドによってその場で変更される配列
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(long[] array,
                                  int fromIndex,
                                  int toIndex,
                                  LongBinaryOperator op)
```
    配列の指定された部分範囲に対してparallelPrefix(long[], LongBinaryOperator)を実行します。
    
    パラメータ:
    
    array - 配列
    
    fromIndex - 最初の要素のインデックス(これを含む)
    
    toIndex - 最後の要素のインデックス(これを含まない)
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex > array.lengthの場合
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(double[] array,
                                  DoubleBinaryOperator op)
```
    指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。たとえば、配列に最初に[2.0, 1.0, 0.0, 3.0]が含まれているときに、その操作で加算が行われた場合、復帰時の配列には[2.0, 3.0, 3.0, 6.0]が含まれています。大きな配列の場合は通常、順次的なループ処理よりも並列的な前置演算の方が効率的です。
    浮動小数点演算は厳密に結合的ではない可能性があるため、返された結果が、その演算が順次的に実行された場合に得られる値と同一でないことがあります。
    
    パラメータ:
    
    array - このメソッドによってその場で変更される配列
    
    op - 累積を行う、副作用のない関数
    
    例外:
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(double[] array,
                                  int fromIndex,
                                  int toIndex,
                                  DoubleBinaryOperator op)
```
    配列の指定された部分範囲に対してparallelPrefix(double[], DoubleBinaryOperator)を実行します。
    
    パラメータ:
    
    array - 配列
    
    fromIndex - 最初の要素のインデックス(これを含む)
    
    toIndex - 最後の要素のインデックス(これを含まない)
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex > array.lengthの場合
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  IntBinaryOperator op)
```
    指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。たとえば、配列に最初に[2, 1, 0, 3]が含まれているときに、その操作で加算が行われた場合、復帰時の配列には[2, 3, 3, 6]が含まれています。大きな配列の場合は通常、順次的なループ処理よりも並列的な前置演算の方が効率的です。
    
    パラメータ:
    
    array - このメソッドによってその場で変更される配列
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - parallelPrefix
```
public static void parallelPrefix(int[] array,
                                  int fromIndex,
                                  int toIndex,
                                  IntBinaryOperator op)
```
    配列の指定された部分範囲に対してparallelPrefix(int[], IntBinaryOperator)を実行します。
    
    パラメータ:
    
    array - 配列
    
    fromIndex - 最初の要素のインデックス(これを含む)
    
    toIndex - 最後の要素のインデックス(これを含まない)
    
    op - 累積を行う、副作用のない結合的な関数
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex > array.lengthの場合
    
    NullPointerException - 指定された配列または関数がnullである場合
    
    導入されたバージョン:
    
    1.8
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値を検索します。この呼出しの前に、sort(long[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(long[] a,
                               int fromIndex,
                               int toIndex,
                               long key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(long[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(int[] a,
                               int key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値を検索します。この呼出しの前に、sort(int[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(int[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(short[] a,
                               short key)
```
    バイナリ・サーチ・アルゴリズムを使用し、指定されたshort値の配列から指定された値を検索します。この呼出しの前に、sort(short[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(short[] a,
                               int fromIndex,
                               int toIndex,
                               short key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたshort値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(short[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(char[] a,
                               char key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値を検索します。この呼出しの前に、sort(char[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(char[] a,
                               int fromIndex,
                               int toIndex,
                               char key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(char[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(byte[] a,
                               byte key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値を検索します。この呼出しの前に、sort(byte[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(byte[] a,
                               int fromIndex,
                               int toIndex,
                               byte key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(byte[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(double[] a,
                               double key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値を検索します。この呼出しの前に、sort(double[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。このメソッドではすべてのNaN値を等価とみなします。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(double[] a,
                               int fromIndex,
                               int toIndex,
                               double key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(double[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。このメソッドではすべてのNaN値を等価とみなします。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(float[] a,
                               float key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値を検索します。この呼出しの前に、sort(float[])メソッドで配列をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。このメソッドではすべてのNaN値を等価とみなします。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
  - binarySearch
```
public static int binarySearch(float[] a,
                               int fromIndex,
                               int toIndex,
                               float key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値の範囲を検索します。この呼出しの前に、sort(float[], int, int)メソッドで範囲をソートする必要があります。リストがソートされていない場合、結果は定義されません。指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。このメソッドではすべてのNaN値を等価とみなします。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。配列は、この呼出しの前に、sort(Object[])メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。リストがソートされていない場合、結果は定義されません。配列が相互に比較可能でない要素、たとえば文字列や整数などである場合、配列はその要素の自然順序付けに従ってソートできず、結果は未定義です。指定されたオブジェクトと同等の要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    ClassCastException - 検索キーが配列の要素と同等でない場合。
  - binarySearch
```
public static int binarySearch(Object[] a,
                               int fromIndex,
                               int toIndex,
                               Object key)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。範囲は、この呼出しの前に、sort(Object[], int, int)メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。リストがソートされていない場合、結果は定義されません。範囲が相互に比較可能でない要素、たとえば文字列や整数などである場合、配列はその要素の自然順序付けに従ってソートできず、結果は未定義です。指定されたオブジェクトと同等の要素が範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    ClassCastException - 検索キーが指定された範囲内の配列の要素と同等でない場合。
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   T key,
                                   Comparator<? super T> c)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。配列は、この呼出しの前に、sort(T[], Comparator)メソッドを使用して、指定されたコンパレータに従って昇順にソートしなければいけません。リストがソートされていない場合、結果は定義されません。指定されたオブジェクトと同等の要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    a - 検索される配列
    
    key - 検索される値
    
    c - 配列が順序付けされるコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    戻り値:
    
    配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    ClassCastException - 指定されたコンパレータで相互に比較可能でない要素が配列に含まれている場合、あるいは検索キーがこのコンパレータで配列の要素と相互に比較できない場合。
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   int fromIndex,
                                   int toIndex,
                                   T key,
                                   Comparator<? super T> c)
```
    バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。範囲は、この呼出しの前に、sort(T[], int, int, Comparator)メソッドを使用して、指定されたコンパレータに従って昇順にソートしなければいけません。リストがソートされていない場合、結果は定義されません。指定されたオブジェクトと同等の要素が範囲に複数ある場合には、どれが検索されるかについての保証はありません。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    a - 検索される配列
    
    fromIndex - 検索される最初の要素(これを含む)のインデックス
    
    toIndex - 検索される最後の要素(これを含まない)のインデックス
    
    key - 検索される値
    
    c - 配列が順序付けされるコンパレータ。 null値は、要素の自然順序付けが使用されることを示す。
    
    戻り値:
    
    指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は(-(挿入ポイント) - 1)。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex。これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
    
    例外:
    
    ClassCastException - 指定されたコンパレータで相互に比較可能でない要素が範囲に含まれている場合、あるいは検索キーがこのコンパレータで範囲の要素と相互に比較できない場合。
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0 or toIndex> a.lengthの場合
    
    導入されたバージョン:
    
    1.6
  - equals
```
public static boolean equals(long[] a,
                             long[] a2)
```
    指定された2つのlong値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(long[] a,
                             int aFromIndex,
                             int aToIndex,
                             long[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された範囲の2つの指定されたlong配列が互いにequalの場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(int[] a,
                             int[] a2)
```
    指定された2つのint値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(int[] a,
                             int aFromIndex,
                             int aToIndex,
                             int[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された範囲のintの2つの指定された配列が互いにequalである場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(short[] a,
                             short[] a2)
```
    指定された2つのshort値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(short[] a,
                             int aFromIndex,
                             int aToIndex,
                             short[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された2つのshortの配列が、指定された範囲で互いにequalの場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(char[] a,
                             char[] a2)
```
    指定された2つのchar値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(char[] a,
                             int aFromIndex,
                             int aToIndex,
                             char[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された2つの文字配列が、指定された範囲にわたってequalである場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    指定された2つのbyte値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(byte[] a,
                             int aFromIndex,
                             int aToIndex,
                             byte[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された2つのバイトの配列が、指定された範囲で互いにequalの場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    指定された2つのboolean値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(boolean[] a,
                             int aFromIndex,
                             int aToIndex,
                             boolean[] b,
                             int bFromIndex,
                             int bToIndex)
```
    ブール値の指定された2つの配列が、指定された範囲にわたって、互いにequalの場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static boolean equals(double[] a,
                             double[] a2)
```
    指定された2つのdouble値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。 2つのdouble値d1とd2は、次の場合に同等とみなされます。
    new Double(d1).equals(new Double(d2))
    演算子==と違って、このメソッドはNaNをそれ自身と同等とみなし、0.0dと -0.0dは同等とみなしません。
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
    
    関連項目:
    
    Double.equals(Object)
  - equals
```
public static boolean equals(double[] a,
                             int aFromIndex,
                             int aToIndex,
                             double[] b,
                             int bFromIndex,
                             int bToIndex)
```
    指定された範囲のdoubleの2つの指定された配列が互いにequalの場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    2つのdouble値d1とd2は、次の場合に同等とみなされます。
    new Double(d1).equals(new Double(d2))
    演算子==と違って、このメソッドはNaNをそれ自身と同等とみなし、0.0dと -0.0dは同等とみなしません。
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
    
    関連項目:
    
    Double.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             float[] a2)
```
    指定された2つのfloat値の配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。次の場合において、2つのfloat値f1およびf2は同等となります。
    new Float(f1).equals(new Float(f2))
    演算子==と違って、このメソッドはNaNをそれ自身と同等とみなし、0.0fと -0.0fは同等とみなしません。
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
    
    関連項目:
    
    Float.equals(Object)
  - equals
```
public static boolean equals(float[] a,
                             int aFromIndex,
                             int aToIndex,
                             float[] b,
                             int bFromIndex,
                             int bToIndex)
```
    floatの指定された2つの配列が、指定された範囲にわたって、互いにequalである場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    次の場合において、2つのfloat値f1およびf2は同等となります。
    new Float(f1).equals(new Float(f2))
    演算子==と違って、このメソッドはNaNをそれ自身と同等とみなし、0.0fと -0.0fは同等とみなしません。
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
    
    関連項目:
    
    Float.equals(Object)
  - equals
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    指定された2つのObjectの配列が互いに同等である場合にtrueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 2つのオブジェクトe1とe2は、Objects.equals(e1, e2)の場合はequalとみなされます。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
  - equals
```
public static boolean equals(Object[] a,
                             int aFromIndex,
                             int aToIndex,
                             Object[] b,
                             int bFromIndex,
                             int bToIndex)
```
    Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    2つのオブジェクトe1とe2は、Objects.equals(e1, e2)の場合はequalとみなされます。
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static <T> boolean equals(T[] a,
                                 T[] a2,
                                 Comparator<? super T> cmp)
```
    指定された2つのObjectの配列が互いに同等である場合にtrueを返します。
    2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。つまり、同じ順序で同じ要素がある2つの配列は同等です。また、2つの配列参照がnullの場合にもそれらは同等とみなされます。
    指定されたコンパレータcmp.compare(e1, e2) == 0が与えられた場合、2つのオブジェクトe1とe2がequalとみなされます。
    
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    2つの配列が同等である場合はtrue
    
    例外:
    
    NullPointerException - コンパレータがnullの場合
    
    導入されたバージョン:
    
    9
  - equals
```
public static <T> boolean equals(T[] a,
                                 int aFromIndex,
                                 int aToIndex,
                                 T[] b,
                                 int bFromIndex,
                                 int bToIndex,
                                 Comparator<? super T> cmp)
```
    Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。
    各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
    指定されたコンパレータcmp.compare(e1, e2) == 0が与えられた場合、2つのオブジェクトe1とe2がequalとみなされます。
    
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 等しいかどうかがテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 等しいかどうかがテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    指定された範囲の2つの配列が等しい場合true
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - 配列またはコンパレータのいずれかがnullの場合
    
    導入されたバージョン:
    
    9
  - fill
```
public static void fill(long[] a,
                        long val)
```
    指定されたlong値の配列の各要素に、指定されたlong値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)
```
    long値で指定された配列の中で、指定された範囲にある各要素に、指定されたlong値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(int[] a,
                        int val)
```
    指定されたint値の配列の各要素に、指定されたint値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    int値で指定された配列の中で、指定された範囲にある各要素に、指定されたint値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(short[] a,
                        short val)
```
    指定されたshort値の配列の各要素に、指定されたshort値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    short値で指定された配列の中で、指定された範囲にある各要素に、指定されたshort値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(char[] a,
                        char val)
```
    指定されたchar値の配列の各要素に、指定されたchar値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    char値で指定された配列の中で、指定された範囲にある各要素に、指定されたchar値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(byte[] a,
                        byte val)
```
    指定されたbyte値の配列の各要素に、指定されたbyte値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)
```
    byte値で指定された配列の中で、指定された範囲にある各要素に、指定されたbyte値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(boolean[] a,
                        boolean val)
```
    指定されたboolean値の配列の各要素に、指定されたboolean値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)
```
    boolean値で指定された配列の中で、指定された範囲にある各要素に、指定されたboolean値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(double[] a,
                        double val)
```
    指定されたdouble値の配列の各要素に、指定されたdouble値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    double値で指定された配列の中で、指定された範囲にある各要素に、指定されたdouble値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(float[] a,
                        float val)
```
    指定されたfloat値の配列の各要素に、指定されたfloat値を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
  - fill
```
public static void fill(float[] a,
                        int fromIndex,
                        int toIndex,
                        float val)
```
    float値で指定された配列の中で、指定された範囲にある各要素に、指定されたfloat値を割り当てます。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
  - fill
```
public static void fill(Object[] a,
                        Object val)
```
    指定されたObjectの配列の各要素に、指定されたObject参照を代入します。
    
    パラメータ:
    
    a - 値を代入する配列
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    ArrayStoreException - 指定された値が、指定された配列に格納できる実行時の型ではない場合
  - fill
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    指定されたObjectの配列で、指定された範囲にある各要素に、指定されたObject参照を代入します。値を代入する範囲はインデックスfromIndex (これを含む)からtoIndex (これを含まない)までとなります。 fromIndex==toIndexの場合、代入する範囲は空になります。
    
    パラメータ:
    
    a - 値を代入する配列
    
    fromIndex - 指定された値を代入する最初の要素(これを含む)のインデックス
    
    toIndex - 指定された値を代入する最後の要素(これを含まない)のインデックス
    
    val - 配列のすべての要素に格納する値
    
    例外:
    
    IllegalArgumentException - fromIndex> toIndexの場合
    
    ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
    
    ArrayStoreException - 指定された値が、指定された配列に格納できる実行時の型ではない場合
  - copyOf
```
public static <T> T[] copyOf(T[] original,
                             int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーにはnullが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。結果として得られる配列のクラスは、元の配列とまったく同じものです。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはnullでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static <T,U> T[] copyOf(U[] original,
                                     int newLength,
                                     Class<? extends T[]> newType)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーにはnullが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。結果となる配列のクラスはnewTypeです。
    
    型パラメータ:
    
    U - 元の配列内のオブジェクトのクラス
    
    T - 返された配列内のオブジェクトのクラス
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    newType - 返されるコピーのクラス
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはnullでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    ArrayStoreException - originalからコピーされる要素が、newTypeクラスの配列に格納できる実行時の型ではない場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static byte[] copyOf(byte[] original,
                            int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには(byte)0が含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static short[] copyOf(short[] original,
                             int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには(short)0が含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static int[] copyOf(int[] original,
                           int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0が含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static long[] copyOf(long[] original,
                            int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0Lが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static char[] copyOf(char[] original,
                            int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnull文字でパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには'\\u000'が含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはnull文字でパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static float[] copyOf(float[] original,
                             int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0fが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static double[] copyOf(double[] original,
                              int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0dが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOf
```
public static boolean[] copyOf(boolean[] original,
                               int newLength)
```
    指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかfalseでパディングします。元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーにはfalseが含まれます。そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
    
    パラメータ:
    
    original - コピーされる配列
    
    newLength - 返されるコピーの長さ
    
    戻り値:
    
    指定された長さにするために切り詰められた、またはfalse要素でパディングされた元の配列のコピー
    
    例外:
    
    NegativeArraySizeException - newLengthが負の値の場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static <T> T[] copyOfRange(T[] original,
                                  int from,
                                  int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素にnullが配置されます。返される配列の長さはto - fromになります。
    結果として得られる配列のクラスは、元の配列とまったく同じものです。
    
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはnullでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static <T,U> T[] copyOfRange(U[] original,
                                          int from,
                                          int to,
                                          Class<? extends T[]> newType)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素にnullが配置されます。返される配列の長さはto - fromになります。結果となる配列のクラスはnewTypeです。
    
    型パラメータ:
    
    U - 元の配列内のオブジェクトのクラス
    
    T - 返された配列内のオブジェクトのクラス
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    newType - 返されるコピーのクラス
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはnullでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    ArrayStoreException - originalからコピーされる要素が、newTypeクラスの配列に格納できる実行時の型ではない場合。
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static byte[] copyOfRange(byte[] original,
                                 int from,
                                 int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に(byte)0が配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static short[] copyOfRange(short[] original,
                                  int from,
                                  int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に(short)0が配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に0が配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static long[] copyOfRange(long[] original,
                                 int from,
                                 int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に0Lが配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static char[] copyOfRange(char[] original,
                                 int from,
                                 int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に'\\u000'が配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはnull文字でパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static float[] copyOfRange(float[] original,
                                  int from,
                                  int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に0fが配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static double[] copyOfRange(double[] original,
                                   int from,
                                   int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素に0dが配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - copyOfRange
```
public static boolean[] copyOfRange(boolean[] original,
                                    int from,
                                    int to)
```
    指定された配列の指定された範囲を新しい配列にコピーします。範囲の最初のインデックス(from)は、ゼロからoriginal.length (これを含む)までの値である必要があります。 original[from]の値は、from == original.lengthまたはfrom == toでないかぎり、コピーの最初の要素に配置されます。元の配列のその後の要素の値は、コピーのその後の要素に配置されます。範囲の最後のインデックス(to)は、from以上でなければならず、original.lengthより大きくてもかまいません。その場合、インデックスがoriginal.length - from以上のコピーのすべての要素にfalseが配置されます。返される配列の長さはto - fromになります。
    
    パラメータ:
    
    original - 範囲のコピー先となる配列
    
    from - コピーされる範囲の最初のインデックス(これを含む)
    
    to - コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)
    
    戻り値:
    
    必要な長さにするために切り詰められた、またはfalse要素でパディングされた、元の配列の指定された範囲を含む新しい配列
    
    例外:
    
    ArrayIndexOutOfBoundsException - from < 0またはfrom> original.lengthの場合
    
    IllegalArgumentException - from> toの場合
    
    NullPointerException - originalがnullの場合
    
    導入されたバージョン:
    
    1.6
  - asList
```
@SafeVarargs
public static <T> List<T> asList(T... a)
```
    指定された配列に連動する固定サイズのリストを返します。返されたリストへの変更は、そのまま配列に書き込まれます。このメソッドは、Collection.toArray()と組み合わせることで、配列ベースのAPIとコレクションベースのAPIの橋渡し役として機能します。また、返されるリストは直列化可能で、RandomAccessを実装します。
    このメソッドは、次の数種類の要素を含むように初期化する固定サイズのリストを作成するための便利な方法も提供します。
    List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
    型パラメータ:
    
    T - 配列内のオブジェクトのクラス
    
    パラメータ:
    
    a - リストの基となる配列
    
    戻り値:
    
    指定された配列のリスト表示
  - hashCode
```
public static int hashCode(long[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのlong配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のLongインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(int[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのnull以外のint配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のIntegerインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(short[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのshort配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のShortインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(char[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのchar配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のCharacterインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(byte[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのbyte配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のByteインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(boolean[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのboolean配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のBooleanインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(float[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのfloat配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のFloatインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(double[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。 2つのdouble配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドから返される値は、同じ順序でaの要素を表す一連のDoubleインスタンスを含むListでhashCodeメソッドを呼び出すことによって取得される値と同じです。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - ハッシュ値を計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
  - hashCode
```
public static int hashCode(Object[] a)
```
    指定された配列の内容に基づくハッシュ・コードを返します。配列に要素以外の配列が含まれる場合、ハッシュ・コードは内容ではなく識別情報に基づいたものになります。これにより、自身を要素として含む配列に対して、このメソッドを1つまたは複数の配列レベルを介して直接または間接的に呼び出すことが可能になります。
    2つの配列aおよびbをArrays.equals(a, b)のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)とも表現できます。
    このメソッドにより返される値は、aがnullである場合を除き、Arrays.asList(a).hashCode()により返される値に等しくなります。aがnullである場合は、0が返されます。
    
    パラメータ:
    
    a - 内容ベースのハッシュ・コードを計算する配列
    
    戻り値:
    
    aの内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
    
    関連項目:
    
    deepHashCode(Object[])
  - deepHashCode
```
public static int deepHashCode(Object[] a)
```
    指定された配列の「深層内容」に基づくハッシュ・コードを返します。配列に要素以外の配列が含まれる場合、ハッシュ・コードは内容およびその他すべてに基づいたものになります。このため、自身を要素として含む配列に対して、このメソッドを1つまたは複数の配列レベルを介して直接または間接的に呼び出すことはできません。この種の呼出し動作は、定義されていません。
    2つの配列aおよびbをArrays.deepEquals(a, b)のように表現できる場合、これをArrays.deepHashCode(a)== Arrays.deepHashCode(b)とも表現できます。
    このメソッドにより返される値の計算は、aと同じ要素を同じ順序で含むリストに対するList.hashCode()により返される値の計算と類似しています。ただし、aの要素e自身が配列の場合、そのハッシュ・コードの計算は、e.hashCode()を呼び出すのではなく、Arrays.hashCode(e)の適切なオーバーロードを呼び出すか(eがプリミティブ型の配列である場合)、Arrays.deepHashCode(e)を再帰的に呼び出す(eが参照型の配列である場合)ことにより実行されます。 aがnullの場合、このメソッドは0を返します。
    
    パラメータ:
    
    a - 深層内容ベースのハッシュ・コードを計算する配列
    
    戻り値:
    
    aの深層内容ベースのハッシュ・コード
    
    導入されたバージョン:
    
    1.5
    
    関連項目:
    
    hashCode(Object[])
  - deepEquals
```
public static boolean deepEquals(Object[] a1,
                                 Object[] a2)
```
    2つの指定された配列が相互に深層で等価な場合、trueを返します。 equals(Object[],Object[])メソッドとは異なり、このメソッドは任意の深さで入れ子にされた配列での使用に適しています。
    両方がnullである場合、2つの配列参照は深層で等価であるとみなされます。また、同数の要素を含む配列を参照する場合、2つの配列内の対応する要素ペアは深層で等価になります。
    nullの可能性がある2つの要素e1およびe2は、次の条件のいずれかに適合する場合、深層で等価です。
    
    e1とe2の両方がオブジェクト参照型の配列であり、Arrays.deepEquals(e1, e2)がtrueを返す
    e1とe2が同じプリミティブ型の配列であり、Arrays.equals(e1, e2)の適切なオーバーロードがtrueを返す。
    e1 == e2
    e1.equals(e2)がtrueを返す。
    この定義では、任意の深さのnull要素が許容される点に注意してください。
    指定された配列のどちらかで、1つまたは複数の配列レベルを介して直接または間接的に自身が要素として含まれる場合、このメソッドの動作は定義されていません。
    パラメータ:
    
    a1 - 同等であるかどうかを判定する1つめの配列
    
    a2 - 同等であるかどうかを判定する2つめの配列
    
    戻り値:
    
    2つの配列が同等である場合はtrue
    
    導入されたバージョン:
    
    1.5
    
    関連項目:
    
    equals(Object[],Object[]), Objects.deepEquals(Object, Object)
  - toString
```
public static String toString(long[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(long)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(int[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(int)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(short[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(short)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(char[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(char)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(byte[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(byte)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(boolean[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(boolean)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(float[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(float)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(double[] a)
```
    指定された配列の文字列表現を返します。文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、String.valueOf(double)により文字列に変換されます。 aがnullの場合、「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
  - toString
```
public static String toString(Object[] a)
```
    指定された配列の文字列表現を返します。配列に他の配列が要素として含まれている場合、それらは、Objectから継承されたObject.toString()メソッドによって文字列に変換されます。Objectには、内容ではなく識別情報が記述されています。
    このメソッドにより返される値は、aがnullである場合を除き、Arrays.asList(a).toString()により返される値に等しくなります。aがnullである場合は、nullが返されます。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
    
    関連項目:
    
    deepToString(Object[])
  - deepToString
```
public static String deepToString(Object[] a)
```
    指定された配列の「深層内容」の文字列表現を返します。配列に要素以外の配列が含まれる場合、文字列表現にはその内容などが含まれます。このメソッドは、多次元配列の文字列への変換用に設計されています。
    文字列表現は、角カッコ(「[]」)で囲まれた配列要素のリストで構成されます。隣接する要素は、文字「, 」(カンマとそれに続く空白文字)で区切られます。要素は、それ自体が配列でないかぎりString.valueOf(Object)により文字列に変換されます。
    要素eがプリミティブ型の配列である場合、Arrays.toString(e)の適切なオーバーロードを呼び出すことで文字列に変換されます。要素eが参照型の配列である場合、このメソッドを再帰的に呼び出すことで文字列に変換されます。
    無限の再帰を避けるため、指定された配列に自身が要素として含まれるか、1つまたは複数の配列レベルを介した自身への間接参照が含まれる場合、自己参照は文字列「[...]」に変換されます。たとえば、自身への参照だけを含む配列は、「[[...]]」として描画されます。
    指定された配列がnullの場合、このメソッドは「null」を返します。
    
    パラメータ:
    
    a - 文字列表現を返す配列
    
    戻り値:
    
    aの文字列表現
    
    導入されたバージョン:
    
    1.5
    
    関連項目:
    
    toString(Object[])
  - setAll
```
public static <T> void setAll(T[] array,
                              IntFunction<? extends T> generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
    そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.apply(i));
    
    型パラメータ:
    
    T - 配列の要素の型
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSetAll
```
public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
    そのジェネレータ関数によって例外がスローされた場合は、parallelSetAllから非チェック例外がスローされ、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.apply(i));
    
    型パラメータ:
    
    T - 配列の要素の型
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - setAll
```
public static void setAll(int[] array,
                          IntUnaryOperator generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
    そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsInt(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
    そのジェネレータ関数によって例外がスローされた場合は、parallelSetAllから非チェック例外がスローされ、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsInt(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - setAll
```
public static void setAll(long[] array,
                          IntToLongFunction generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
    そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsLong(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
    そのジェネレータ関数によって例外がスローされた場合は、parallelSetAllから非チェック例外がスローされ、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsLong(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - setAll
```
public static void setAll(double[] array,
                          IntToDoubleFunction generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。
    そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsDouble(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)
```
    指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。
    そのジェネレータ関数によって例外がスローされた場合は、parallelSetAllから非チェック例外がスローされ、配列は不確定な状態のままになります。
    APIのノート:
    
    ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
    IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsDouble(i));
    
    パラメータ:
    
    array - 初期化される配列
    
    generator - インデックスを受け入れ、その位置に必要な値を生成する関数
    
    例外:
    
    NullPointerException - そのジェネレータがnullの場合
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array)
```
    指定された配列のすべてに適用されるSpliteratorを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    型パラメータ:
    
    T - 要素の型
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    指定された配列の指定された範囲に適用されるSpliteratorを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    型パラメータ:
    
    T - 要素の型
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array)
```
    指定された配列のすべてに適用されるSpliterator.OfIntを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array,
                                            int startInclusive,
                                            int endExclusive)
```
    指定された配列の指定された範囲に適用されるSpliterator.OfIntを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array)
```
    指定された配列のすべてに適用されるSpliterator.OfLongを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    配列の要素のスプリッテレータ
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    指定された配列の指定された範囲に適用されるSpliterator.OfLongを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array)
```
    指定された配列のすべてに適用されるSpliterator.OfDoubleを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    導入されたバージョン:
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array,
                                               int startInclusive,
                                               int endExclusive)
```
    指定された配列の指定された範囲に適用されるSpliterator.OfDoubleを返します。
    そのスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.ORDERED、およびSpliterator.IMMUTABLEを報告します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    その配列の要素のスプリッテレータ
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array)
```
    指定された配列をソースとして使用して、逐次的なStreamを返します。
    
    型パラメータ:
    
    T - 配列の要素の型
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    配列のStream
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)
```
    指定された配列の指定された範囲をソースとして使用して、逐次的なStreamを返します。
    
    型パラメータ:
    
    T - 配列の要素の型
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    配列の範囲のStream
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static IntStream stream(int[] array)
```
    指定された配列をソースとして使用して、逐次的なIntStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    配列のIntStream
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static IntStream stream(int[] array,
                               int startInclusive,
                               int endExclusive)
```
    指定された配列の指定された範囲をソースとして使用して、逐次的なIntStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    配列の範囲のIntStream
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static LongStream stream(long[] array)
```
    指定された配列をソースとして使用して、逐次的なLongStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    配列のLongStream
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static LongStream stream(long[] array,
                                int startInclusive,
                                int endExclusive)
```
    指定された配列の指定された範囲をソースとして使用して、逐次的なLongStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    配列の範囲のLongStream
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array)
```
    指定された配列をソースとして使用して、逐次的なDoubleStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    戻り値:
    
    配列のDoubleStream
    
    導入されたバージョン:
    
    1.8
  - stream
```
public static DoubleStream stream(double[] array,
                                  int startInclusive,
                                  int endExclusive)
```
    指定された配列の指定された範囲をソースとして使用して、逐次的なDoubleStreamを返します。
    
    パラメータ:
    
    array - 使用中に変更されないと想定される配列
    
    startInclusive - 適用される最初のインデックス(これを含む)
    
    endExclusive - 適用される最後のインデックスの直後のインデックス
    
    戻り値:
    
    配列の範囲のDoubleStream
    
    例外:
    
    ArrayIndexOutOfBoundsException - startInclusiveが負の場合、endExclusiveがstartInclusiveよりも小さい場合、またはendExclusiveが配列サイズよりも大きい場合
    
    導入されたバージョン:
    
    1.8
  - compare
```
public static int compare(boolean[] a,
                          boolean[] b)
```
    2つのboolean配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Boolean.compare(boolean, boolean)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(boolean[], boolean[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Boolean.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(boolean[] a,
                          int aFromIndex,
                          int aToIndex,
                          boolean[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのboolean配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をBoolean.compare(boolean, boolean)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(boolean[], int, int, boolean[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(byte[] a,
                          byte[] b)
```
    2つのbyte配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Byte.compare(byte, byte)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], byte[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(byte[] a,
                          int aFromIndex,
                          int aToIndex,
                          byte[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのbyte配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をByte.compare(byte, byte)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], int, int, byte[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(byte[] a,
                                  byte[] b)
```
    2つのbyte配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Byte.compareUnsigned(byte, byte)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], byte[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(byte[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  byte[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    2つのbyte配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をByte.compareUnsigned(byte, byte)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], int, int, byte[], int, int)を参照してください。)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(short[] a,
                          short[] b)
```
    2つのshort配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Short.compare(short, short)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], short[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(short[] a,
                          int aFromIndex,
                          int aToIndex,
                          short[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのshort配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をShort.compare(short, short)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], int, int, short[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(short[] a,
                                  short[] b)
```
    2つのshort配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Short.compareUnsigned(short, short)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], short[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(short[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  short[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    2つのshort配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をShort.compareUnsigned(short, short)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], int, int, short[], int, int)を参照してください。)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(char[] a,
                          char[] b)
```
    2つのchar配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Character.compare(char, char)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(char[], char[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Character.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(char[] a,
                          int aFromIndex,
                          int aToIndex,
                          char[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのchar配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をCharacter.compare(char, char)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(char[], int, int, char[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Character.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(int[] a,
                          int[] b)
```
    2つのint配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Integer.compare(int, int)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(int[] a,
                          int aFromIndex,
                          int aToIndex,
                          int[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのint配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をInteger.compare(int, int)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int, int, int[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(int[] a,
                                  int[] b)
```
    2つのint配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Integer.compareUnsigned(int, int)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(int[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  int[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    2つのint配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をInteger.compareUnsigned(int, int)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int, int, int[], int, int)を参照してください。)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(long[] a,
                          long[] b)
```
    2つのlong配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Long.compare(long, long)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], long[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(long[] a,
                          int aFromIndex,
                          int aToIndex,
                          long[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのlong配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をLong.compare(long, long)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], int, int, long[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(long[] a,
                                  long[] b)
```
    2つのlong配列を辞書的に比較し、要素を数値的にunsignedとして扱います。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Long.compareUnsigned(long, long)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], long[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compareUnsigned(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compareUnsigned
```
public static int compareUnsigned(long[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  long[] b,
                                  int bFromIndex,
                                  int bToIndex)
```
    2つのlong配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をLong.compareUnsigned(long, long)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], int, int, long[], int, int)を参照してください。)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(float[] a,
                          float[] b)
```
    2つのfloat配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Float.compare(float, float)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(float[], float[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Float.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(float[] a,
                          int aFromIndex,
                          int aToIndex,
                          float[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのfloat配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をFloat.compare(float, float)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(float[], int, int, float[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Float.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(double[] a,
                          double[] b)
```
    2つのdouble配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、Double.compare(double, double)のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(double[], double[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Double.compare(a[i], b[i]); return a.length - b.length;
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static int compare(double[] a,
                          int aFromIndex,
                          int aToIndex,
                          double[] b,
                          int bFromIndex,
                          int bToIndex)
```
    指定された範囲にわたって2つのdouble配列を辞書順に比較します。
    指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素をDouble.compare(double, double)のように比較した結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(double[], int, int, double[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは次のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Double.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            T[] b)
```
    比較可能な要素内の2つのObject配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、字句比較は、プレフィクスの長さであるそれぞれの配列内の索引iで型Tの2つの要素を比較した結果です:
    Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[i], b[i])
    それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(Object[], Object[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。 null配列要素は、非null配列要素よりも辞書編集的に見なされます。 2つのnull配列要素は等しいとみなされます。
    比較はequalsと一貫しており、より具体的には、配列aとbについては以下のとおりです:
    Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
    APIのノート:
    
    このメソッドは、(非null配列参照と要素の場合)のように動作します:
    int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return a[i].compareTo(b[i]); return a.length - b.length;
    
    型パラメータ:
    
    T - 比較可能な配列要素の型
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    導入されたバージョン:
    
    9
  - compare
```
public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            int aFromIndex,
                                                            int aToIndex,
                                                            T[] b,
                                                            int bFromIndex,
                                                            int bToIndex)
```
    指定された範囲にわたって2つのObject配列を辞書順に比較します。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、字句比較は、プレフィクスの長さであるそれぞれの配列内の相対索引iで型Tの2つの要素を比較した結果です:
    Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[aFromIndex + i, b[bFromIndex + i])
    それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(Object[], int, int, Object[], int, int)を参照してください。)
    この比較は、equalsと一貫しており、より具体的には、指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ配列aおよびbについて:
    Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
    APIのノート:
    
    このメソッドは、(非null配列要素の場合)のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return a[aFromIndex + i].compareTo(b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    型パラメータ:
    
    T - 比較可能な配列要素の型
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static <T> int compare(T[] a,
                              T[] b,
                              Comparator<? super T> cmp)
```
    指定されたコンパレータを使用して、2つのObject配列を辞書順に比較します。
    2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、指定されたコンパレータと、プレフィクスの長さであるそれぞれの配列内のインデックスの2つの要素を比較した結果です。それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(Object[], Object[])を参照してください。)
    null配列参照は、非null配列参照よりも辞書編集的に小さいと見なされます。 2つのnull配列参照は等しいとみなされます。
    APIのノート:
    
    このメソッドは、(非null配列参照の場合)のように動作します:
    int i = Arrays.mismatch(a, b, cmp); if (i >= 0 && i < Math.min(a.length, b.length)) return cmp.compare(a[i], b[i]); return a.length - b.length;
    
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 比較する最初の配列
    
    b - 比較する2番目の配列
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値0; 第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0より大きい値
    
    例外:
    
    NullPointerException - コンパレータがnullの場合
    
    導入されたバージョン:
    
    9
  - compare
```
public static <T> int compare(T[] a,
                              int aFromIndex,
                              int aToIndex,
                              T[] b,
                              int bFromIndex,
                              int bToIndex,
                              Comparator<? super T> cmp)
```
    指定された範囲にわたって2つのObject配列を辞書順に比較します。
    指定された範囲にわたって2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、指定された比較器との比較の結果です。それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(Object[], int, int, Object[], int, int)を参照してください。)
    APIのノート:
    
    このメソッドは、(非null配列要素の場合)のように動作します:
    int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, cmp); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return cmp.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
    
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 比較する最初の配列
    
    aFromIndex - 比較される最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - 比較される最初の配列の最後の要素のインデックス(exclusive)
    
    b - 比較する2番目の配列
    
    bFromIndex - 比較される第2の配列内の第1の要素のインデックス(inclusive)
    
    bToIndex - 比較される第2の配列内の最後の要素のインデックス(exclusive)
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値0; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0より大きい値
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - 配列またはコンパレータのいずれかがnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(boolean[] a,
                           boolean[] b)
```
    2つのboolean配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(boolean[] a,
                           int aFromIndex,
                           int aToIndex,
                           boolean[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのboolean配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(byte[] a,
                           byte[] b)
```
    2つのbyte配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(byte[] a,
                           int aFromIndex,
                           int aToIndex,
                           byte[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのbyte配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(char[] a,
                           char[] b)
```
    2つのchar配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(char[] a,
                           int aFromIndex,
                           int aToIndex,
                           char[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのchar配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(short[] a,
                           short[] b)
```
    2つのshort配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(short[] a,
                           int aFromIndex,
                           int aToIndex,
                           short[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのshort配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(int[] a,
                           int[] b)
```
    2つのint配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(int[] a,
                           int aFromIndex,
                           int aToIndex,
                           int[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのint配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(long[] a,
                           long[] b)
```
    2つのlong配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(long[] a,
                           int aFromIndex,
                           int aToIndex,
                           long[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのlong配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(float[] a,
                           float[] b)
```
    2つのfloat配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && Float.compare(a[pl], b[pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(float[] a,
                           int aFromIndex,
                           int aToIndex,
                           float[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのfloat配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(double[] a,
                           double[] b)
```
    2つのdouble配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && Double.compare(a[pl], b[pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(double[] a,
                           int aFromIndex,
                           int aToIndex,
                           double[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのdouble配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(Object[] a,
                           Object[] b)
```
    2つのObject配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && !Objects.equals(a[pl], b[pl])
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static int mismatch(Object[] a,
                           int aFromIndex,
                           int aToIndex,
                           Object[] b,
                           int bFromIndex,
                           int bToIndex)
```
    2つのObject配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - いずれかの配列がnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static <T> int mismatch(T[] a,
                               T[] b,
                               Comparator<? super T> cmp)
```
    2つのObject配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。
    指定されたコンパレータを使用して、各配列の2つの配列要素が等しくないかどうかを判定します。
    2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl, cmp) cmp.compare(a[pl], b[pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    2つの非null配列、aおよびbは、次の式がtrueである場合、適切なプレフィクスを共有します:
    a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length), cmp)
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    b - 不一致がテストされる第2の配列
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    2つの配列間の最初の不一致のインデックス、それ以外の場合は-1。
    
    例外:
    
    NullPointerException - 配列またはコンパレータのいずれかがnullの場合
    
    導入されたバージョン:
    
    9
  - mismatch
```
public static <T> int mismatch(T[] a,
                               int aFromIndex,
                               int aToIndex,
                               T[] b,
                               int bFromIndex,
                               int bToIndex,
                               Comparator<? super T> cmp)
```
    2つのObject配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。
    指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。それ以外の場合は、不一致はありません。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueであれば、長さplの共通プレフィクスを共有します:
    pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) && cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
    0の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。
    指定された範囲[aFromIndex、atoIndex]および[bFromIndex、btoIndex]を持つ2つの非null配列、aおよびbは、次の式がtrueである場合:
    (aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), cmp)
    型パラメータ:
    
    T - 配列要素の型
    
    パラメータ:
    
    a - 不一致がテストされる最初の配列
    
    aFromIndex - テストされる最初の配列の最初の要素のインデックス(inclusive)
    
    aToIndex - テストされる最初の配列の最後の要素のインデックス(exclusive)
    
    b - 不一致がテストされる第2の配列
    
    bFromIndex - テストされる第2の配列の第1の要素のインデックス(inclusive)
    
    bToIndex - テストされるの2番目の配列の最後の要素のインデックス(exclusive)
    
    cmp - 配列要素を比較するコンパレータ
    
    戻り値:
    
    指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ-1。
    
    例外:
    
    IllegalArgumentException - aFromIndex > aToIndexまたはbFromIndex > bToIndexの場合
    
    ArrayIndexOutOfBoundsException - aFromIndex < 0 or aToIndex > a.lengthまたはbFromIndex < 0 or bToIndex > b.lengthの場合
    
    NullPointerException - 配列またはコンパレータのいずれかがnullの場合
    
    導入されたバージョン:
    
    9

クラスArrays

メソッドのサマリー

クラス java.lang.Objectで宣言されたメソッド

メソッドの詳細

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

sort

sort

sort

sort

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

parallelPrefix

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals

equals