モジュール java.base
パッケージ java.util

クラスArrays

java.lang.Object
java.util.Arrays
public final 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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。
    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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。
    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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。
    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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。
    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つのブール配列が互いにequalである場合は、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つのバイト配列が互いにequalである場合は、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の配列が相互にequalである場合は、trueを返します。
    static boolean
    equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)
    指定された範囲の2つのcharの配列が互いにequalである場合、trueを返します。
    static boolean
    equals(double[] a, double[] a2)
    指定された2つのdouble配列が互いにequalである場合は、trueを返します。
    static boolean
    equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)
    指定された範囲の2つのdoubleの指定された配列が、互いにequalである場合にtrueを返します。
    static boolean
    equals(float[] a, float[] a2)
    指定された2つの浮動小数点配列が互いにequalである場合は、trueを返します。
    static boolean
    equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)
    指定された範囲の浮動小数点数の指定された2つの配列が互いにequalである場合、trueを返します。
    static boolean
    equals(int[] a, int[] a2)
    指定された2つのintの配列が相互にequalである場合は、trueを返します。
    static boolean
    equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
    指定された範囲の2つの指定されたintの配列が互いにequalである場合、trueを返します。
    static boolean
    equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
    指定された範囲のlongの2つの指定された配列が、互いにequalである場合にtrueを返します。
    static boolean
    equals(long[] a, long[] a2)
    指定されたlongの2つの配列が互いにequalである場合は、trueを返します。
    static boolean
    equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
    指定された範囲のshortsの2つの指定された配列が互いにequalである場合、trueを返します。
    static boolean
    equals(short[] a, short[] a2)
    指定された2つのshorts配列が互いにequalである場合は、trueを返します。
    static boolean
    equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)
    指定された範囲のオブジェクトの2つの指定された配列が、互いにequalである場合にtrueを返します。
    static boolean
    equals(Object[] a, Object[] a2)
    指定した2つのオブジェクトの配列が相互にequalである場合は、trueを返します。
    static <T> boolean
    equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)
    指定された範囲のオブジェクトの2つの指定された配列が、互いにequalである場合にtrueを返します。
    static <T> boolean
    equals(T[] a, T[] a2, Comparator<? super T> cmp)
    指定した2つのオブジェクトの配列が相互にequalである場合は、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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列

    • sort

      public static void sort(int[] a, int fromIndex, int toIndex)
      指定された範囲の配列を昇順にソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon Bentley、Joshua Blochを基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列

    • sort

      public static void sort(long[] a, int fromIndex, int toIndex)
      指定された範囲の配列を昇順にソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon Bentley、Joshua Blochを基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列

    • sort

      public static void sort(short[] a, int fromIndex, int toIndex)
      指定された範囲の配列を昇順にソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon Bentley、Joshua Blochを基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列

    • sort

      public static void sort(char[] a, int fromIndex, int toIndex)
      指定された範囲の配列を昇順にソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon Bentley、Joshua Blochを基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列

    • sort

      public static void sort(byte[] a, int fromIndex, int toIndex)
      指定された範囲の配列を昇順にソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon Bentley、Joshua Blochを基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) 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を基準にしたデュアル・ソートです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      fromIndex - ソートされる最初の要素(これを含む)のインデックス
      toIndex - ソートされる最後の要素(これを含まない)のインデックス
      例外:
      IllegalArgumentException - fromIndex> toIndexの場合
      ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合

    • parallelSort

      public static void parallelSort(byte[] a)
      指定された配列を数値の昇順でソートします。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(byte[] a, int fromIndex, int toIndex)
      配列の指定された範囲を数値の昇順でソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      fromIndex - ソートされる最初の要素(これを含む)のインデックス
      toIndex - ソートされる最後の要素(これを含まない)のインデックス
      例外:
      IllegalArgumentException - fromIndex> toIndexの場合
      ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(char[] a)
      指定された配列を数値の昇順でソートします。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(char[] a, int fromIndex, int toIndex)
      配列の指定された範囲を数値の昇順でソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      fromIndex - ソートされる最初の要素(これを含む)のインデックス
      toIndex - ソートされる最後の要素(これを含まない)のインデックス
      例外:
      IllegalArgumentException - fromIndex> toIndexの場合
      ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(short[] a)
      指定された配列を数値の昇順でソートします。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(short[] a, int fromIndex, int toIndex)
      配列の指定された範囲を数値の昇順でソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      fromIndex - ソートされる最初の要素(これを含む)のインデックス
      toIndex - ソートされる最後の要素(これを含まない)のインデックス
      例外:
      IllegalArgumentException - fromIndex> toIndexの場合
      ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(int[] a)
      指定された配列を数値の昇順でソートします。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(int[] a, int fromIndex, int toIndex)
      配列の指定された範囲を数値の昇順でソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      fromIndex - ソートされる最初の要素(これを含む)のインデックス
      toIndex - ソートされる最後の要素(これを含まない)のインデックス
      例外:
      IllegalArgumentException - fromIndex> toIndexの場合
      ArrayIndexOutOfBoundsException - fromIndex < 0またはtoIndex> a.lengthの場合
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(long[] a)
      指定された配列を数値の昇順でソートします。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      a - ソートされる配列
      導入されたバージョン:
      1.8

    • parallelSort

      public static void parallelSort(long[] a, int fromIndex, int toIndex)
      配列の指定された範囲を数値の昇順でソートします。 ソート範囲は、インデックスfromIndex (これを含む)からインデックスtoIndex (これを含まない)までとなります。 fromIndex == toIndexの場合、ソート範囲は空になります。
      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      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値は等価と見なされます。

      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      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値は等価と見なされます。

      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      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値は等価と見なされます。

      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      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値は等価と見なされます。

      実装上のノート:
      ソート・アルゴリズムは、Vladimir Yaroslavskiy、Jon BentleyおよびJosh BlochでのDual-Pivot Quicksortです。 このアルゴリズムはすべてのデータ・セットに対するO(n log(n))のパフォーマンスを提供し、通常、従来の(one-pivot) Quicksort実装よりも高速です。
      パラメータ:
      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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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 - 検索される値
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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値は、要素の自然順序付けが使用されることを示す。
      戻り値:
      検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、(-(insertion point) - 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値は、要素の自然順序付けが使用されることを示す。
      戻り値:
      指定した範囲内の配列に含まれている場合は、検索キーのインデックス。それ以外の場合は、(-(insertion point) - 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)
      指定されたlongの2つの配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue

    • equals

      public static boolean equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
      指定された範囲のlongの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(int[] a, int[] a2)
      指定された2つのintの配列が相互にequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue

    • equals

      public static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
      指定された範囲の2つの指定されたintの配列が互いに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つのshorts配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue

    • equals

      public static boolean equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
      指定された範囲のshortsの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(char[] a, char[] a2)
      指定された2つのcharの配列が相互にequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue

    • equals

      public static boolean equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)
      指定された範囲の2つのcharの配列が互いに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つのバイト配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      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つのブール配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      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配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。 次の場合は、2つのdoublesのd1とd2が同じとみなされます: 
          Double.valueOf(d1).equals(Double.valueOf(d2))
      (==演算子とは異なり、このメソッドはNaNがそれ自体と等しいとみなし、0.0 dは -0.0 dと等しくありません。)
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue
      関連項目:

    • equals

      public static boolean equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)
      指定された範囲の2つのdoubleの指定された配列が、互いにequalである場合にtrueを返します。

      2つの配列は、各範囲でカバーされる要素の数が同じで、2つの配列内の指定された範囲にあるすべての対応する要素のペアが等しい場合に、同じとみなされます。 言い換えると、2つの配列が同じ順序で、指定された範囲に同じ要素が含まれる場合、同じ配列になります。

      次の場合は、2つのdoublesのd1とd2が同じとみなされます: 

          Double.valueOf(d1).equals(Double.valueOf(d2))
      (==演算子とは異なり、このメソッドはNaNがそれ自体と等しいとみなし、0.0 dは -0.0 dと等しくありません。)

      パラメータ:
      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(float[] a, float[] a2)
      指定された2つの浮動小数点配列が互いにequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。 次の場合、2つの浮動小数点f1とf2は同じとみなされます: 
          Float.valueOf(f1).equals(Float.valueOf(f2))
      (==演算子とは異なり、このメソッドはNaNがそれ自体と等しいとみなし、0.0 fは -0.0 fと等しくありません。)
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue
      関連項目:

    • equals

      public static boolean equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)
      指定された範囲の浮動小数点数の指定された2つの配列が互いにequalである場合、trueを返します。

      2つの配列は、各範囲でカバーされる要素の数が同じで、2つの配列内の指定された範囲にあるすべての対応する要素のペアが等しい場合に、同じとみなされます。 言い換えると、2つの配列が同じ順序で、指定された範囲に同じ要素が含まれる場合、同じ配列になります。

      次の場合、2つの浮動小数点f1とf2は同じとみなされます: 

          Float.valueOf(f1).equals(Float.valueOf(f2))
      (==演算子とは異なり、このメソッドはNaNがそれ自体と等しいとみなし、0.0 fは -0.0 fと等しくありません。)

      パラメータ:
      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(Object[] a, Object[] a2)
      指定した2つのオブジェクトの配列が相互にequalである場合は、trueを返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 2つのオブジェクトe1とe2は、Objects.equals(e1, e2)の場合はequalとみなされます。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。
      パラメータ:
      a - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue

    • equals

      public static boolean equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)
      指定された範囲のオブジェクトの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つのオブジェクトの配列が相互にequalである場合は、trueを返します。

      2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、両方がnullの場合、2つの配列参照は同じとみなされます。

      指定されたコンパレータ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)
      指定された範囲のオブジェクトの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です。
      型パラメータ:
      T - 返された配列内のオブジェクトのクラス
      U - 元の配列内のオブジェクトのクラス
      パラメータ:
      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つの配列に同じ値が含まれます。 コピーで有効でオリジナルではない索引の場合、コピーには'\u0000'が含まれます。 そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。
      パラメータ:
      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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、nullは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、nullは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、to - fromになります。 結果の配列は、クラスnewTypeです。
      型パラメータ:
      T - 返された配列内のオブジェクトのクラス
      U - 元の配列内のオブジェクトのクラス
      パラメータ:
      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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、(byte)0は、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、(short)0は、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、0は、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、0Lは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、'\u0000'は、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、0fは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、0dは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)の初期索引は、0からoriginal.length (0を含む)の間にする必要があります。 original[from]の値は、コピー(from == original.lengthまたはfrom == to以外)の初期要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to)の最終索引(from以上である必要があります)は、original.lengthより大きい場合があります。この場合、falseは、original.length - from以上の索引を持つコピーのすべての要素に配置されます。 返される配列の長さは、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)
      指定された配列に連動する固定サイズのリストを返します。 配列に対する変更は返されるリストに表示され、リストに対する変更は配列に表示されます。 返されるリストはSerializableで、RandomAccessを実装します。

      返されるリストは、返されるリストのサイズを変更するオプションのCollectionメソッドを実装します。 これらのメソッドは変更されずにUnsupportedOperationExceptionをスローします。

      指定された配列の実際のコンポーネント・タイプがタイプ・パラメータTと異なる場合、返されるリストでの操作によってArrayStoreExceptionがスローされる可能性があります。

      APIのノート:
      このメソッドは、Collection.toArray()と組み合わせることで、配列ベースのAPIとコレクションベースのAPIの橋渡し役として機能します。

      このメソッドは、既存の配列をラップする方法を提供します: 

      
     Integer[] numbers = ...
     ...
     List<Integer> values = Arrays.asList(numbers);

      このメソッドは、次の数種類の要素を含むように初期化する固定サイズのリストを作成するための便利な方法も提供します。 

      
     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

      このメソッドにより返されるリストは変更可能です。 変更不可能なリストを作成するには、Collections.unmodifiableListまたは「変更不可能なリスト」を使用します。

      型パラメータ:
      T - 配列内のオブジェクトのクラス
      パラメータ:
      a - リストの基となる配列
      戻り値:
      指定された配列のリスト表示
      例外:
      NullPointerException - 指定された配列がnullの場合

    • hashCode

      public static int hashCode(long[] a)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのlong配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)など、null以外の2つのint配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのshort配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのchar配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのbyte配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのboolean配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのfloat配列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)
      指定された配列の内容に基づくハッシュ・コードを返します。 Arrays.equals(a, b)などの2つのdouble配列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つまたは複数の配列レベルを介して直接または間接的に呼び出すことが可能になります。

      Arrays.equals(a, b)などの2つの配列aおよびbでは、Arrays.hashCode(a) == Arrays.hashCode(b)でも同様です。

      このメソッドから返される値は、aがnullの場合を除き、Arrays.asList(a).hashCode()によって返される値と等しくなります。この場合、0が返されます。

      パラメータ:
      a - 内容ベースのハッシュ・コードを計算する配列
      戻り値:
      aのコンテンツ・ベースのハッシュ・コード
      導入されたバージョン:
      1.5
      関連項目:

    • deepHashCode

      public static int deepHashCode(Object[] a)
      指定された配列の「深層内容」に基づくハッシュ・コードを返します。 配列に要素以外の配列が含まれる場合、ハッシュ・コードは内容およびその他すべてに基づいたものになります。 このため、自身を要素として含む配列に対して、このメソッドを1つまたは複数の配列レベルを介して直接または間接的に呼び出すことはできません。 この種の呼出し動作は、定義されていません。

      Arrays.deepEquals(a, b)などの2つの配列aおよびbでは、Arrays.deepHashCode(a) == Arrays.deepHashCode(b)でも同様です。

      このメソッドによって返される値の計算は、aと同じ順序で同じ要素を含むリストでList.hashCode()によって返される値と似ていますが、1つの違いがあります: aの要素eがそれ自体が配列である場合、そのハッシュ・コードは、e.hashCode()をコールするのではなく、eがプリミティブ型の配列の場合はArrays.hashCode(e)の適切なオーバーロードをコールするか、eが参照型の配列の場合はArrays.deepHashCode(e)を再帰的にコールすることで計算されます。 aがnullの場合、このメソッドは0を返します。

      パラメータ:
      a - 深層内容ベースのハッシュ・コードを計算する配列
      戻り値:
      aのディープ・コンテンツ・ベースのハッシュ・コード
      導入されたバージョン:
      1.5
      関連項目:

    • deepEquals

      public static boolean deepEquals(Object[] a1, Object[] a2)
      指定された2つの配列が相互に「深く等しい」である場合は、trueを返します。 equals(Object[],Object[])メソッドとは異なり、このメソッドは任意の深さで入れ子にされた配列での使用に適しています。

      2つの配列参照は、両方がnullの場合、または同じ数の要素を含む配列を参照し、2つの配列内の対応するすべての要素ペアが深く等しい場合、深く等しいとみなされます。

      次のいずれかの条件に当てはまる場合、2つのnull要素e1およびe2は深く等しくなります:

      • e1およびe2は、オブジェクト参照型の配列であり、Arrays.deepEquals(e1, e2) would return trueです
      • e1とe2は同じプリミティブ型の配列であり、Arrays.equals(e1, e2)の適切なオーバーロードはtrueを返します。
      • e1 == e2
      • e1.equals(e2)はtrueを返します。
      この定義では、null要素を任意の深さで許可することに注意してください。

      指定された配列のどちらかで、1つまたは複数の配列レベルを介して直接または間接的に自身が要素として含まれる場合、このメソッドの動作は定義されていません。

      パラメータ:
      a1 - 同等であるかどうかを判定する1つめの配列
      a2 - 同等であるかどうかを判定する2つめの配列
      戻り値:
      2つの配列が等しい場合はtrue
      導入されたバージョン:
      1.5
      関連項目:

    • 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()メソッドによって文字列に変換されます。このメソッドでは、配列の内容ではなくidentitiesが記述されます。

      このメソッドから返される値は、aがnullの場合を除き、Arrays.asList(a).toString()によって返される値と等しくなります。この場合、"null"が返されます。

      パラメータ:
      a - 文字列表現を返す配列
      戻り値:
      aの文字列表現
      導入されたバージョン:
      1.5
      関連項目:

    • deepToString

      public static String deepToString(Object[] a)
      指定された配列の「深層内容」の文字列表現を返します。 配列に要素以外の配列が含まれる場合、文字列表現にはその内容などが含まれます。 このメソッドは、多次元配列の文字列への変換用に設計されています。

      文字列表現は、配列の要素のリストで構成され、大カッコ("[]")で囲まれています。 隣接する要素は、", " (カンマの後ろにスペース)という文字で区切られます。 要素は、配列でないかぎり、String.valueOf(Object)のように文字列に変換されます。

      要素eがプリミティブ型の配列の場合、Arrays.toString(e)の適切なオーバーロードを起動すると、その要素が文字列に変換されます。 要素eが参照型の配列の場合、このメソッドを再帰的に呼び出すことによって文字列に変換されます。

      無限の再帰を回避するために、指定した配列が自身を要素として含んでいるか、1つ以上のレベルの配列を介してそれ自体への間接参照が含まれている場合、自己参照は文字列"[...]"に変換されます。 たとえば、それ自体への参照のみを含む配列は、"[[...]]"としてレンダリングされます。

      このメソッドは、指定された配列がnullの場合に"null"を返します。

      パラメータ:
      a - 文字列表現を返す配列
      戻り値:
      aの文字列表現
      導入されたバージョン:
      1.5
      関連項目:

    • 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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Boolean.compare(boolean, boolean)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Byte.compare(byte, byte)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。

      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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Byte.compareUnsigned(byte, byte)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Short.compare(short, short)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。

      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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Short.compareUnsigned(short, short)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Character.compare(char, char)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Integer.compare(int, int)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。

      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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Integer.compareUnsigned(int, int)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Long.compare(long, long)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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配列を辞書学的に比較し、要素を数値的に符号なしとして扱います。

      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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Long.compareUnsigned(long, long)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Float.compare(float, float)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの配列が、指定された範囲で共通のプレフィクスを共有する場合、辞書編集比較は、Double.compare(double, double)のように、プレフィクスの長さである各配列内の相対索引で2つの要素を比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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)
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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つの要素と比較した結果になります。 それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は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 - 配列要素を比較するコンパレータ
      戻り値:
      指定された範囲で、最初の配列と2番目の配列が同じで、同じ順序で同じ要素を含む場合、値0。次の場合、0より小さい値指定された範囲、最初の配列は2番目の配列より辞書順で小さく、指定された範囲で最初の配列が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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式がtrueの場合、長さplの共通プレフィクスを共有します: 

      
     pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]
      一般的なプレフィクス長0は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式が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は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式が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は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式が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は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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を返します。 索引は、0 (inclusive)から小さい配列の長さ(inclusive)までの範囲になります。

      指定されたコンパレータを使用して、各配列の2つの配列要素が等しくないかどうかを判断します。

      2つの配列が共通のプレフィクスを共有している場合、返される索引は共通のプレフィクスの長さであり、それぞれの配列内のその索引の2つの要素間に不一致があることがわかります。 一方の配列がもう一方の配列の適切なプレフィクスである場合、返される索引は小さい配列の長さであり、その後にその索引は大きい配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      aおよびbという2つの非null配列は、次の式が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は、各配列の最初の要素が一致しないことを示します。

      aおよびbという2つの非null配列は、次の式が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を返します。 索引は、0 (inclusive)から小さい範囲の(inclusive)までの範囲になります。

      指定された範囲の2つの配列で共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、各配列内のその相対索引の2つの要素間で不一致が発生します。 1つの配列がもう一方の配列の適切なプレフィクスであり、指定された範囲を超える場合、返される相対索引は小さい範囲の長さであり、その相対索引は大きい範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

      次の式がtrueの場合、2つの非null配列(aおよびbと指定された範囲[ aFromIndex、aToIndex)および[ bFromIndex、bToIndex)が、長さ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は、各配列の最初の要素が一致しないことを示します。

      2つの非null配列、指定された範囲[aFromIndex, aToIndex)および[bFromIndex, bToIndex)を各々持つ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