指定された配列参照が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>>
intcompare
(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>>
intcompare
(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[] 指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるか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
指定された範囲のオブジェクトの2つの指定された配列が、互いにequalである場合にtrueを返します。static boolean
指定した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
指定されたObjectの配列で、指定された範囲にある各要素に、指定されたObject参照を代入します。static void
指定された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
指定された配列の内容に基づくハッシュ・コードを返します。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
指定された範囲における2つのObject
配列間の最初の不一致の相対索引を検索し、戻します。不一致が見つからない場合は -1を返します。static int
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>>
voidparallelSort
(T[] a) 指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。static <T extends Comparable<? super T>>
voidparallelSort
(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
指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。static void
指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。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
指定された配列の文字列表現を返します。
-
メソッドの詳細
-
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
バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。 配列は、この呼出しの前に、sort(Object[])
メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。 リストがソートされていない場合、結果は定義されません。 配列が相互に比較可能でない要素、たとえば文字列や整数などである場合、配列はその要素の自然順序付けに従ってソートできず、結果は未定義です。 指定されたオブジェクトと同等の要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 検索キーのインデックス(配列に含まれている場合)。それ以外の場合は、
(-(insertion point) - 1)
。 「挿入ポイント」は、キーが配列に挿入されるポイントとして定義されます: キーより大きい最初の要素の索引。配列内のすべての要素が指定のキーより小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
ClassCastException
- 検索キーが配列の要素と同等でない場合。
-
binarySearch
バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。 範囲は、この呼出しの前に、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
指定した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
指定されたObjectの配列の各要素に、指定されたObject参照を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値- 例外:
ArrayStoreException
- 指定された値が、指定された配列に格納できる実行時の型ではない場合
-
fill
指定された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
指定された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
指定された配列の文字列表現を返します。 配列に他の配列が要素として含まれている場合、配列は、Object
から継承されたObject.toString()
メソッドによって文字列に変換されます。このメソッドでは、配列の内容ではなくidentitiesが記述されます。このメソッドから返される値は、
a
がnull
の場合を除き、Arrays.asList(a).toString()
によって返される値と等しくなります。この場合、"null"
が返されます。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
- 関連項目:
-
deepToString
指定された配列の「深層内容」の文字列表現を返します。 配列に要素以外の配列が含まれる場合、文字列表現にはその内容などが含まれます。 このメソッドは、多次元配列の文字列への変換用に設計されています。文字列表現は、配列の要素のリストで構成され、大カッコ(
"[]"
)で囲まれています。 隣接する要素は、", "
(カンマの後ろにスペース)という文字で区切られます。 要素は、配列でないかぎり、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
-
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
-
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つの要素を比較した結果、辞書学的比較が行われます:
それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は2つの配列の長さを比較した結果になります。 (共通および適切なプレフィクスの定義については、Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[i], b[i])
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つの要素を、次のように比較した結果になります:
それ以外の場合、一方の配列はもう一方の配列の適切なプレフィクスであり、辞書編集比較は2つの範囲の長さを比較した結果になります。 (共通および適切なプレフィクスの定義については、Comparator.nullsFirst(Comparator.<T>naturalOrder()). compare(a[aFromIndex + i, b[bFromIndex + i])
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
-