public class Arrays extends Object
指定された配列参照が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
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。static int
compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)
2つのbyte
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。static int
compareUnsigned(int[] a, int[] b)
2つのint
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。static int
compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
2つのint
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。static int
compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
2つのlong
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。static int
compareUnsigned(long[] a, long[] b)
2つのlong
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。static int
compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
2つのshort
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。static int
compareUnsigned(short[] a, short[] b)
2つのshort
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。static boolean[]
copyOf(boolean[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかfalse
でパディングします。static byte[]
copyOf(byte[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static char[]
copyOf(char[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnull文字でパディングします。static double[]
copyOf(double[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static float[]
copyOf(float[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static int[]
copyOf(int[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static long[]
copyOf(long[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static short[]
copyOf(short[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。static <T> T[]
copyOf(T[] original, int newLength)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。static <T, U> T[]
copyOf(U[] original, int newLength, Class<? extends T[]> newType)
指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。static boolean[]
copyOfRange(boolean[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static byte[]
copyOfRange(byte[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static char[]
copyOfRange(char[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static double[]
copyOfRange(double[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static float[]
copyOfRange(float[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static int[]
copyOfRange(int[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static long[]
copyOfRange(long[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static short[]
copyOfRange(short[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static <T> T[]
copyOfRange(T[] original, int from, int to)
指定された配列の指定された範囲を新しい配列にコピーします。static <T, U> T[]
copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
指定された配列の指定された範囲を新しい配列にコピーします。static boolean
deepEquals(Object[] a1, Object[] a2)
2つの指定された配列が相互に深層で等価な場合、true
を返します。static int
deepHashCode(Object[] a)
指定された配列の「深層内容」に基づくハッシュ・コードを返します。static String
deepToString(Object[] a)
指定された配列の「深層内容」の文字列表現を返します。static boolean
equals(boolean[] a, boolean[] a2)
指定された2つのboolean値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)
ブール値の指定された2つの配列が、指定された範囲にわたって、互いにequalの場合にtrueを返します。static boolean
equals(byte[] a, byte[] a2)
指定された2つのbyte値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)
指定された2つのバイトの配列が、指定された範囲で互いにequalの場合にtrueを返します。static boolean
equals(char[] a, char[] a2)
指定された2つのchar値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)
指定された2つの文字配列が、指定された範囲にわたってequalである場合にtrueを返します。static boolean
equals(double[] a, double[] a2)
指定された2つのdouble値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)
指定された範囲のdoubleの2つの指定された配列が互いにequalの場合にtrueを返します。static boolean
equals(float[] a, float[] a2)
指定された2つのfloat値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)
floatの指定された2つの配列が、指定された範囲にわたって、互いにequalである場合にtrueを返します。static boolean
equals(int[] a, int[] a2)
指定された2つのint値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
指定された範囲のintの2つの指定された配列が互いにequalである場合にtrueを返します。static boolean
equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
指定された範囲の2つの指定されたlong配列が互いにequalの場合にtrueを返します。static boolean
equals(long[] a, long[] a2)
指定された2つのlong値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
指定された2つのshortの配列が、指定された範囲で互いにequalの場合にtrueを返します。static boolean
equals(short[] a, short[] a2)
指定された2つのshort値の配列が互いに同等である場合にtrue
を返します。static boolean
equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)
Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。static boolean
equals(Object[] a, Object[] a2)
指定された2つのObjectの配列が互いに同等である場合にtrue
を返します。static <T> boolean
equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)
Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。static <T> boolean
equals(T[] a, T[] a2, Comparator<? super T> cmp)
指定された2つのObjectの配列が互いに同等である場合にtrue
を返します。static void
fill(boolean[] a, boolean val)
指定されたboolean値の配列の各要素に、指定されたboolean値を代入します。static void
fill(boolean[] a, int fromIndex, int toIndex, boolean val)
boolean値で指定された配列の中で、指定された範囲にある各要素に、指定されたboolean値を割り当てます。static void
fill(byte[] a, byte val)
指定されたbyte値の配列の各要素に、指定されたbyte値を代入します。static void
fill(byte[] a, int fromIndex, int toIndex, byte val)
byte値で指定された配列の中で、指定された範囲にある各要素に、指定されたbyte値を割り当てます。static void
fill(char[] a, char val)
指定されたchar値の配列の各要素に、指定されたchar値を代入します。static void
fill(char[] a, int fromIndex, int toIndex, char val)
char値で指定された配列の中で、指定された範囲にある各要素に、指定されたchar値を割り当てます。static void
fill(double[] a, double val)
指定されたdouble値の配列の各要素に、指定されたdouble値を代入します。static void
fill(double[] a, int fromIndex, int toIndex, double val)
double値で指定された配列の中で、指定された範囲にある各要素に、指定されたdouble値を割り当てます。static void
fill(float[] a, float val)
指定されたfloat値の配列の各要素に、指定されたfloat値を代入します。static void
fill(float[] a, int fromIndex, int toIndex, float val)
float値で指定された配列の中で、指定された範囲にある各要素に、指定されたfloat値を割り当てます。static void
fill(int[] a, int val)
指定されたint値の配列の各要素に、指定されたint値を代入します。static void
fill(int[] a, int fromIndex, int toIndex, int val)
int値で指定された配列の中で、指定された範囲にある各要素に、指定されたint値を割り当てます。static void
fill(long[] a, int fromIndex, int toIndex, long val)
long値で指定された配列の中で、指定された範囲にある各要素に、指定されたlong値を割り当てます。static void
fill(long[] a, long val)
指定されたlong値の配列の各要素に、指定されたlong値を代入します。static void
fill(short[] a, int fromIndex, int toIndex, short val)
short値で指定された配列の中で、指定された範囲にある各要素に、指定されたshort値を割り当てます。static void
fill(short[] a, short val)
指定されたshort値の配列の各要素に、指定されたshort値を代入します。static void
fill(Object[] a, int fromIndex, int toIndex, Object val)
指定されたObjectの配列で、指定された範囲にある各要素に、指定されたObject参照を代入します。static void
fill(Object[] a, Object val)
指定されたObjectの配列の各要素に、指定されたObject参照を代入します。static int
hashCode(boolean[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(byte[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(char[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(double[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(float[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(int[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(long[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(short[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
hashCode(Object[] a)
指定された配列の内容に基づくハッシュ・コードを返します。static int
mismatch(boolean[] a, boolean[] b)
2つのboolean
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)
2つのboolean
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(byte[] a, byte[] b)
2つのbyte
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)
2つのbyte
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(char[] a, char[] b)
2つのchar
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)
2つのchar
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(double[] a, double[] b)
2つのdouble
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)
2つのdouble
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(float[] a, float[] b)
2つのfloat
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)
2つのfloat
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(int[] a, int[] b)
2つのint
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
2つのint
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)
2つのlong
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(long[] a, long[] b)
2つのlong
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)
2つのshort
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(short[] a, short[] b)
2つのshort
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static int
mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)
2つのObject
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static int
mismatch(Object[] a, Object[] b)
2つのObject
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static <T> int
mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)
2つのObject
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。static <T> int
mismatch(T[] a, T[] b, Comparator<? super T> cmp)
2つのObject
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。static void
parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)
配列の指定された部分範囲に対してparallelPrefix(double[], DoubleBinaryOperator)
を実行します。static void
parallelPrefix(double[] array, DoubleBinaryOperator op)
指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。static void
parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)
配列の指定された部分範囲に対してparallelPrefix(int[], IntBinaryOperator)
を実行します。static void
parallelPrefix(int[] array, IntBinaryOperator op)
指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。static void
parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)
配列の指定された部分範囲に対してparallelPrefix(long[], LongBinaryOperator)
を実行します。static void
parallelPrefix(long[] array, LongBinaryOperator op)
指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。static <T> void
parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)
配列の指定された部分範囲に対してparallelPrefix(Object[], BinaryOperator)
を実行します。static <T> void
parallelPrefix(T[] array, BinaryOperator<T> op)
指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。static void
parallelSetAll(double[] array, IntToDoubleFunction generator)
指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。static void
parallelSetAll(int[] array, IntUnaryOperator generator)
指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。static void
parallelSetAll(long[] array, IntToLongFunction generator)
指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。static <T> void
parallelSetAll(T[] array, IntFunction<? extends T> generator)
指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。static void
parallelSort(byte[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(byte[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(char[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(char[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(double[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(double[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(float[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(float[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(int[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(int[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(long[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(long[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static void
parallelSort(short[] a)
指定された配列を数値の昇順でソートします。static void
parallelSort(short[] a, int fromIndex, int toIndex)
配列の指定された範囲を数値の昇順でソートします。static <T extends Comparable<? super T>>
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
sort(Object[] a)
指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。static void
sort(Object[] a, int fromIndex, int toIndex)
指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。static <T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。static <T> void
sort(T[] a, Comparator<? super T> c)
指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。static Spliterator.OfDouble
spliterator(double[] array)
指定された配列のすべてに適用されるSpliterator.OfDouble
を返します。static Spliterator.OfDouble
spliterator(double[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲に適用されるSpliterator.OfDouble
を返します。static Spliterator.OfInt
spliterator(int[] array)
指定された配列のすべてに適用されるSpliterator.OfInt
を返します。static Spliterator.OfInt
spliterator(int[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲に適用されるSpliterator.OfInt
を返します。static Spliterator.OfLong
spliterator(long[] array)
指定された配列のすべてに適用されるSpliterator.OfLong
を返します。static Spliterator.OfLong
spliterator(long[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲に適用されるSpliterator.OfLong
を返します。static <T> Spliterator<T>
spliterator(T[] array)
指定された配列のすべてに適用されるSpliterator
を返します。static <T> Spliterator<T>
spliterator(T[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲に適用されるSpliterator
を返します。static DoubleStream
stream(double[] array)
指定された配列をソースとして使用して、逐次的なDoubleStream
を返します。static DoubleStream
stream(double[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲をソースとして使用して、逐次的なDoubleStream
を返します。static IntStream
stream(int[] array)
指定された配列をソースとして使用して、逐次的なIntStream
を返します。static IntStream
stream(int[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲をソースとして使用して、逐次的なIntStream
を返します。static LongStream
stream(long[] array)
指定された配列をソースとして使用して、逐次的なLongStream
を返します。static LongStream
stream(long[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲をソースとして使用して、逐次的なLongStream
を返します。static <T> Stream<T>
stream(T[] array)
指定された配列をソースとして使用して、逐次的なStream
を返します。static <T> Stream<T>
stream(T[] array, int startInclusive, int endExclusive)
指定された配列の指定された範囲をソースとして使用して、逐次的なStream
を返します。static String
toString(boolean[] a)
指定された配列の文字列表現を返します。static String
toString(byte[] a)
指定された配列の文字列表現を返します。static String
toString(char[] a)
指定された配列の文字列表現を返します。static String
toString(double[] a)
指定された配列の文字列表現を返します。static String
toString(float[] a)
指定された配列の文字列表現を返します。static String
toString(int[] a)
指定された配列の文字列表現を返します。static String
toString(long[] a)
指定された配列の文字列表現を返します。static String
toString(short[] a)
指定された配列の文字列表現を返します。static String
toString(Object[] a)
指定された配列の文字列表現を返します。
-
メソッドの詳細
-
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
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(long[] a, int fromIndex, int toIndex, long key)バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(long[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(int[] a, int key)バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値を検索します。 この呼出しの前に、sort(int[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key)バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(int[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(short[] a, short key)バイナリ・サーチ・アルゴリズムを使用し、指定されたshort値の配列から指定された値を検索します。 この呼出しの前に、sort(short[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(short[] a, int fromIndex, int toIndex, short key)バイナリ・サーチ・アルゴリズムを使用して、指定されたshort値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(short[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(char[] a, char key)バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値を検索します。 この呼出しの前に、sort(char[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(char[] a, int fromIndex, int toIndex, char key)バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(char[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(byte[] a, byte key)バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値を検索します。 この呼出しの前に、sort(byte[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(byte[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(double[] a, double key)バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値を検索します。 この呼出しの前に、sort(double[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。 このメソッドではすべてのNaN値を等価とみなします。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(double[] a, int fromIndex, int toIndex, double key)バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(double[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。 このメソッドではすべてのNaN値を等価とみなします。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static int binarySearch(float[] a, float key)バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値を検索します。 この呼出しの前に、sort(float[])
メソッドで配列をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。 このメソッドではすべてのNaN値を等価とみなします。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。
-
binarySearch
public static int binarySearch(float[] a, int fromIndex, int toIndex, float key)バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値の範囲を検索します。 この呼出しの前に、sort(float[], int, int)
メソッドで範囲をソートする必要があります。 リストがソートされていない場合、結果は定義されません。 指定された値を持つ要素がこの範囲に複数ある場合には、どれが検索されるかについての保証はありません。 このメソッドではすべてのNaN値を等価とみなします。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。 配列は、この呼出しの前に、sort(Object[])
メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。 リストがソートされていない場合、結果は定義されません。 配列が相互に比較可能でない要素、たとえば文字列や整数などである場合、配列はその要素の自然順序付けに従ってソートできず、結果は未定義です。 指定されたオブジェクトと同等の要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列key
- 検索される値- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
ClassCastException
- 検索キーが配列の要素と同等でない場合。
-
binarySearch
バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。 範囲は、この呼出しの前に、sort(Object[], int, int)
メソッドを使用して要素の自然順序付けに従って昇順にソートする必要があります。 リストがソートされていない場合、結果は定義されません。 範囲が相互に比較可能でない要素、たとえば文字列や整数などである場合、配列はその要素の自然順序付けに従ってソートできず、結果は未定義です。 指定されたオブジェクトと同等の要素が範囲に複数ある場合には、どれが検索されるかについての保証はありません。- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
ClassCastException
- 検索キーが指定された範囲内の配列の要素と同等でない場合。IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
binarySearch
public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。 配列は、この呼出しの前に、sort(T[], Comparator)
メソッドを使用して、指定されたコンパレータに従って昇順にソートしなければいけません。 リストがソートされていない場合、結果は定義されません。 指定されたオブジェクトと同等の要素が配列に複数ある場合には、どれが検索されるかについての保証はありません。- 型パラメータ:
T
- 配列内のオブジェクトのクラス- パラメータ:
a
- 検索される配列key
- 検索される値c
- 配列が順序付けされるコンパレータ。null
値は、要素の自然順序付けが使用されることを示す。- 戻り値:
- 配列内に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな最初の要素のインデックス。配列内のすべての要素が指定されたキーよりも小さい場合はa.length
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
ClassCastException
- 指定されたコンパレータで相互に比較可能でない要素が配列に含まれている場合、あるいは検索キーがこのコンパレータで配列の要素と相互に比較できない場合。
-
binarySearch
public static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。 範囲は、この呼出しの前に、sort(T[], int, int, Comparator)
メソッドを使用して、指定されたコンパレータに従って昇順にソートしなければいけません。 リストがソートされていない場合、結果は定義されません。 指定されたオブジェクトと同等の要素が範囲に複数ある場合には、どれが検索されるかについての保証はありません。- 型パラメータ:
T
- 配列内のオブジェクトのクラス- パラメータ:
a
- 検索される配列fromIndex
- 検索される最初の要素(これを含む)のインデックスtoIndex
- 検索される最後の要素(これを含まない)のインデックスkey
- 検索される値c
- 配列が順序付けされるコンパレータ。null
値は、要素の自然順序付けが使用されることを示す。- 戻り値:
- 指定された範囲内の配列に検索キーがある場合は検索キーのインデックス。それ以外の場合は
(-(挿入ポイント) - 1)
。 挿入時点は、そのキーが配列に挿入される時点として定義される。つまり、そのキーよりも大きな範囲内にある最初の要素のインデックス。範囲内のすべての要素が指定されたキーよりも小さい場合はtoIndex
。 これにより、キーが見つかった場合にのみ戻り値が>= 0になることが保証される。 - 例外:
ClassCastException
- 指定されたコンパレータで相互に比較可能でない要素が範囲に含まれている場合、あるいは検索キーがこのコンパレータで範囲の要素と相互に比較できない場合。IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0 or toIndex> a.length
の場合- 導入されたバージョン:
- 1.6
-
equals
public static boolean equals(long[] a, long[] a2)指定された2つのlong値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)指定された範囲の2つの指定されたlong配列が互いにequalの場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(int[] a, int[] a2)指定された2つのint値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)指定された範囲のintの2つの指定された配列が互いにequalである場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(short[] a, short[] a2)指定された2つのshort値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)指定された2つのshortの配列が、指定された範囲で互いにequalの場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(char[] a, char[] a2)指定された2つのchar値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)指定された2つの文字配列が、指定された範囲にわたってequalである場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(byte[] a, byte[] a2)指定された2つのbyte値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)指定された2つのバイトの配列が、指定された範囲で互いにequalの場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(boolean[] a, boolean[] a2)指定された2つのboolean値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)ブール値の指定された2つの配列が、指定された範囲にわたって、互いにequalの場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static boolean equals(double[] a, double[] a2)指定された2つのdouble値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。 2つのdouble値d1
とd2
は、次の場合に同等とみなされます。new Double(d1).equals(new Double(d2))
==
演算子とは異なり、このメソッドはNaN
がそれ自体と等しいとみなし、0.0 dは -0.0 dと等しくありません。)- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
- 関連項目:
Double.equals(Object)
-
equals
public static boolean equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)指定された範囲のdoubleの2つの指定された配列が互いにequalの場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
2つのdouble値
d1
とd2
は、次の場合に同等とみなされます。new Double(d1).equals(new Double(d2))
==
演算子とは異なり、このメソッドはNaN
がそれ自体と等しいとみなし、0.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
- 関連項目:
Double.equals(Object)
-
equals
public static boolean equals(float[] a, float[] a2)指定された2つのfloat値の配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。 次の場合において、2つのfloat値f1
およびf2
は同等となります。new Float(f1).equals(new Float(f2))
==
演算子とは異なり、このメソッドはNaN
がそれ自体と等しいとみなし、0.0 fは -0.0 fと等しくありません。)- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
- 関連項目:
Float.equals(Object)
-
equals
public static boolean equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)floatの指定された2つの配列が、指定された範囲にわたって、互いにequalである場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
次の場合において、2つのfloat値
f1
およびf2
は同等となります。new Float(f1).equals(new Float(f2))
==
演算子とは異なり、このメソッドはNaN
がそれ自体と等しいとみなし、0.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
- 関連項目:
Float.equals(Object)
-
equals
指定された2つのObjectの配列が互いに同等である場合にtrue
を返します。 2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 2つのオブジェクトe1
とe2
は、Objects.equals(e1, e2)
の場合はequalとみなされます。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照がnull
の場合にもそれらは同等とみなされます。- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
-
equals
public static boolean equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
2つのオブジェクト
e1
とe2
は、Objects.equals(e1, e2)
の場合はequalとみなされます。- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
equals
public static <T> boolean equals(T[] a, T[] a2, Comparator<? super T> cmp)指定された2つのObjectの配列が互いに同等である場合にtrue
を返します。2つの配列が同等とみなされるのは、両方の配列に同じ数の要素があり、対応する対の要素がすべて同等である場合です。 つまり、同じ順序で同じ要素がある2つの配列は同等です。 また、2つの配列参照が
null
の場合にもそれらは同等とみなされます。指定されたコンパレータ
cmp.compare(e1, e2) == 0
が与えられた場合、2つのオブジェクトe1
とe2
がequalとみなされます。- 型パラメータ:
T
- 配列要素の型- パラメータ:
a
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列cmp
- 配列要素を比較するコンパレータ- 戻り値:
- 2つの配列が同等である場合は
true
- 例外:
NullPointerException
- コンパレータがnull
の場合- 導入されたバージョン:
- 9
-
equals
public static <T> boolean equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。各範囲でカバーされる要素の数が同じであり、2つの配列の指定された範囲を超える要素のすべての対応するペアが等しい場合、2つの配列は等しいとみなされます。 つまり、指定された範囲に同じ要素が同じ順序で含まれていると、2つの配列が等しいことになります。
指定されたコンパレータ
cmp.compare(e1, e2) == 0
が与えられた場合、2つのオブジェクトe1
とe2
がequalとみなされます。- 型パラメータ:
T
- 配列要素の型- パラメータ:
a
- 等しいかどうかがテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 等価かどうかテストする2番目の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)cmp
- 配列要素を比較するコンパレータ- 戻り値:
- 指定された範囲の2つの配列が等しい場合
true
- 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- 配列またはコンパレータのいずれかがnull
の場合- 導入されたバージョン:
- 9
-
fill
public static void fill(long[] a, long val)指定されたlong値の配列の各要素に、指定されたlong値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(long[] a, int fromIndex, int toIndex, long val)long値で指定された配列の中で、指定された範囲にある各要素に、指定されたlong値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(int[] a, int val)指定されたint値の配列の各要素に、指定されたint値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(int[] a, int fromIndex, int toIndex, int val)int値で指定された配列の中で、指定された範囲にある各要素に、指定されたint値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(short[] a, short val)指定されたshort値の配列の各要素に、指定されたshort値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(short[] a, int fromIndex, int toIndex, short val)short値で指定された配列の中で、指定された範囲にある各要素に、指定されたshort値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(char[] a, char val)指定されたchar値の配列の各要素に、指定されたchar値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(char[] a, int fromIndex, int toIndex, char val)char値で指定された配列の中で、指定された範囲にある各要素に、指定されたchar値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(byte[] a, byte val)指定されたbyte値の配列の各要素に、指定されたbyte値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(byte[] a, int fromIndex, int toIndex, byte val)byte値で指定された配列の中で、指定された範囲にある各要素に、指定されたbyte値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(boolean[] a, boolean val)指定されたboolean値の配列の各要素に、指定されたboolean値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)boolean値で指定された配列の中で、指定された範囲にある各要素に、指定されたboolean値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(double[] a, double val)指定されたdouble値の配列の各要素に、指定されたdouble値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(double[] a, int fromIndex, int toIndex, double val)double値で指定された配列の中で、指定された範囲にある各要素に、指定されたdouble値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
public static void fill(float[] a, float val)指定されたfloat値の配列の各要素に、指定されたfloat値を代入します。- パラメータ:
a
- 値を代入する配列val
- 配列のすべての要素に格納する値
-
fill
public static void fill(float[] a, int fromIndex, int toIndex, float val)float値で指定された配列の中で、指定された範囲にある各要素に、指定されたfloat値を割り当てます。 値を代入する範囲はインデックスfromIndex
(これを含む)からtoIndex
(これを含まない)までとなります。fromIndex==toIndex
の場合、代入する範囲は空になります。- パラメータ:
a
- 値を代入する配列fromIndex
- 指定された値を代入する最初の要素(これを含む)のインデックスtoIndex
- 指定された値を代入する最後の要素(これを含まない)のインデックスval
- 配列のすべての要素に格納する値- 例外:
IllegalArgumentException
-fromIndex> toIndex
の場合ArrayIndexOutOfBoundsException
-fromIndex < 0
またはtoIndex> a.length
の場合
-
fill
指定された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
です。- 型パラメータ:
U
- 元の配列内のオブジェクトのクラスT
- 返された配列内のオブジェクトのクラス- パラメータ:
original
- コピーされる配列newLength
- 返されるコピーの長さnewType
- 返されるコピーのクラス- 戻り値:
- 指定された長さにするために切り詰められた、またはnullでパディングされた元の配列のコピー
- 例外:
NegativeArraySizeException
-newLength
が負の値の場合NullPointerException
-original
がnullの場合ArrayStoreException
-original
からコピーされる要素が、newType
クラスの配列に格納できる実行時の型ではない場合- 導入されたバージョン:
- 1.6
-
copyOf
public static byte[] copyOf(byte[] original, int newLength)指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。 元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。 コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには(byte)0
が含まれます。 そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。- パラメータ:
original
- コピーされる配列newLength
- 返されるコピーの長さ- 戻り値:
- 指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
- 例外:
NegativeArraySizeException
-newLength
が負の値の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOf
public static short[] copyOf(short[] original, int newLength)指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。 元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。 コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには(short)0
が含まれます。 そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。- パラメータ:
original
- コピーされる配列newLength
- 返されるコピーの長さ- 戻り値:
- 指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
- 例外:
NegativeArraySizeException
-newLength
が負の値の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOf
public static int[] copyOf(int[] original, int newLength)指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。 元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。 コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0
が含まれます。 そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。- パラメータ:
original
- コピーされる配列newLength
- 返されるコピーの長さ- 戻り値:
- 指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
- 例外:
NegativeArraySizeException
-newLength
が負の値の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOf
public static long[] copyOf(long[] original, int newLength)指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。 元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。 コピーでは有効でも、元の配列では有効でないインデックスがある場合、コピーには0L
が含まれます。 そのようなインデックスは、指定された長さが元の配列の長さより大きい場合にだけ存在します。- パラメータ:
original
- コピーされる配列newLength
- 返されるコピーの長さ- 戻り値:
- 指定された長さにするために切り詰められた、またはゼロでパディングされた元の配列のコピー
- 例外:
NegativeArraySizeException
-newLength
が負の値の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOf
public static char[] copyOf(char[] original, int newLength)指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnull文字でパディングします。 元の配列とコピーの両方ですべてのインデックスが有効な場合は、2つの配列に同じ値が含まれます。 コピーで有効でオリジナルではない索引の場合、コピーには'\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
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素にnull
が配置されます。 返される配列の長さはto - from
になります。結果として得られる配列のクラスは、元の配列とまったく同じものです。
- 型パラメータ:
T
- 配列内のオブジェクトのクラス- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはnullでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static <T, U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素にnull
が配置されます。 返される配列の長さはto - from
になります。 結果となる配列のクラスはnewType
です。- 型パラメータ:
U
- 元の配列内のオブジェクトのクラスT
- 返された配列内のオブジェクトのクラス- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)newType
- 返されるコピーのクラス- 戻り値:
- 必要な長さにするために切り詰められた、またはnullでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合ArrayStoreException
-original
からコピーされる要素が、newType
クラスの配列に格納できる実行時の型ではない場合。- 導入されたバージョン:
- 1.6
-
copyOfRange
public static byte[] copyOfRange(byte[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に(byte)0
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static short[] copyOfRange(short[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に(short)0
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static int[] copyOfRange(int[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に0
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static long[] copyOfRange(long[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に0L
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static char[] copyOfRange(char[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲(to
)の最終索引(from
以上である必要があります)は、original.length
より大きい場合があります。この場合、'\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
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に0f
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static double[] copyOfRange(double[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素に0d
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはゼロでパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
copyOfRange
public static boolean[] copyOfRange(boolean[] original, int from, int to)指定された配列の指定された範囲を新しい配列にコピーします。 範囲の最初のインデックス(from
)は、ゼロからoriginal.length
(これを含む)までの値である必要があります。original[from]
の値は、from == original.length
またはfrom == to
でないかぎり、コピーの最初の要素に配置されます。 元の配列のその後の要素の値は、コピーのその後の要素に配置されます。 範囲の最後のインデックス(to
)は、from
以上でなければならず、original.length
より大きくてもかまいません。その場合、インデックスがoriginal.length - from
以上のコピーのすべての要素にfalse
が配置されます。 返される配列の長さはto - from
になります。- パラメータ:
original
- 範囲のコピー先となる配列from
- コピーされる範囲の最初のインデックス(これを含む)to
- コピーされる範囲の最後のインデックス(これを含まない)。 (このインデックスは配列の外側に存在することもある。)- 戻り値:
- 必要な長さにするために切り詰められた、またはfalse要素でパディングされた、元の配列の指定された範囲を含む新しい配列
- 例外:
ArrayIndexOutOfBoundsException
-from < 0
またはfrom> original.length
の場合IllegalArgumentException
-from> to
の場合NullPointerException
-original
がnullの場合- 導入されたバージョン:
- 1.6
-
asList
@SafeVarargspublic static <T> List<T> asList(T... a)指定された配列に連動する固定サイズのリストを返します。 配列に対する変更は返されるリストに表示され、リストに対する変更は配列に表示されます。 返されるリストはSerializable
で、RandomAccess
を実装します。返されるリストは、返されるリストのサイズを変更するオプションの
Collection
メソッドを実装します。 これらのメソッドは変更されずにUnsupportedOperationException
をスローします。- 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)指定された配列の内容に基づくハッシュ・コードを返します。 2つのlong
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のLong
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(int[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのnull以外のint
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のInteger
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(short[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのshort
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のShort
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(char[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのchar
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のCharacter
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(byte[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのbyte
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のByte
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(boolean[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのboolean
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のBoolean
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(float[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのfloat
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のFloat
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(double[] a)指定された配列の内容に基づくハッシュ・コードを返します。 2つのdouble
配列a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドから返される値は、同じ順序で
a
の要素を表す一連のDouble
インスタンスを含むList
でhashCode
メソッドを呼び出すことによって取得される値と同じです。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- ハッシュ値を計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
-
hashCode
public static int hashCode(Object[] a)指定された配列の内容に基づくハッシュ・コードを返します。 配列に要素以外の配列が含まれる場合、ハッシュ・コードは内容ではなく識別情報に基づいたものになります。 これにより、自身を要素として含む配列に対して、このメソッドを1つまたは複数の配列レベルを介して直接または間接的に呼び出すことが可能になります。2つの配列
a
およびb
をArrays.equals(a, b)
のように表現できる場合、これをArrays.hashCode(a)== Arrays.hashCode(b)
とも表現できます。このメソッドにより返される値は、
a
がnull
である場合を除き、Arrays.asList(a).hashCode()
により返される値に等しくなります。aがnullである場合は、0
が返されます。- パラメータ:
a
- 内容ベースのハッシュ・コードを計算する配列- 戻り値:
a
の内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
- 関連項目:
deepHashCode(Object[])
-
deepHashCode
public static int deepHashCode(Object[] a)指定された配列の「深層内容」に基づくハッシュ・コードを返します。 配列に要素以外の配列が含まれる場合、ハッシュ・コードは内容およびその他すべてに基づいたものになります。 このため、自身を要素として含む配列に対して、このメソッドを1つまたは複数の配列レベルを介して直接または間接的に呼び出すことはできません。 この種の呼出し動作は、定義されていません。2つの配列
a
およびb
をArrays.deepEquals(a, b)
のように表現できる場合、これをArrays.deepHashCode(a)== Arrays.deepHashCode(b)
とも表現できます。このメソッドにより返される値の計算は、
a
と同じ要素を同じ順序で含むリストに対するList.hashCode()
により返される値の計算と類似しています。ただし、a
の要素e
自身が配列の場合、そのハッシュ・コードの計算は、e.hashCode()
を呼び出すのではなく、Arrays.hashCode(e)
の適切なオーバーロードを呼び出すか(e
がプリミティブ型の配列である場合)、Arrays.deepHashCode(e)
を再帰的に呼び出す(e
が参照型の配列である場合)ことにより実行されます。a
がnull
の場合、このメソッドは0を返します。- パラメータ:
a
- 深層内容ベースのハッシュ・コードを計算する配列- 戻り値:
a
の深層内容ベースのハッシュ・コード- 導入されたバージョン:
- 1.5
- 関連項目:
hashCode(Object[])
-
deepEquals
2つの指定された配列が相互に深層で等価な場合、true
を返します。equals(Object[],Object[])
メソッドとは異なり、このメソッドは任意の深さで入れ子にされた配列での使用に適しています。両方が
null
である場合、2つの配列参照は深層で等価であるとみなされます。また、同数の要素を含む配列を参照する場合、2つの配列内の対応する要素ペアは深層で等価になります。null
の可能性がある2つの要素e1
およびe2
は、次の条件のいずれかに適合する場合、深層で等価です。-
e1
とe2
の両方がオブジェクト参照型の配列であり、Arrays.deepEquals(e1, e2)
がtrueを返す -
e1
とe2
が同じプリミティブ型の配列であり、Arrays.equals(e1, e2)
の適切なオーバーロードがtrueを返す。 -
e1 == e2
-
e1.equals(e2)
がtrueを返す。
null
要素が許容される点に注意してください。指定された配列のどちらかで、1つまたは複数の配列レベルを介して直接または間接的に自身が要素として含まれる場合、このメソッドの動作は定義されていません。
- パラメータ:
a1
- 同等であるかどうかを判定する1つめの配列a2
- 同等であるかどうかを判定する2つめの配列- 戻り値:
- 2つの配列が同等である場合は
true
- 導入されたバージョン:
- 1.5
- 関連項目:
equals(Object[],Object[])
,Objects.deepEquals(Object, Object)
-
-
toString
public static String toString(long[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(long)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(int[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(int)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(short[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(short)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(char[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(char)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(byte[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(byte)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(boolean[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(boolean)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(float[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(float)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
public static String toString(double[] a)指定された配列の文字列表現を返します。 文字列表現は、角カッコ(「[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、String.valueOf(double)
により文字列に変換されます。a
がnull
の場合、「null
」を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
-
toString
指定された配列の文字列表現を返します。 配列に他の配列が要素として含まれている場合、それらは、Object
から継承されたObject.toString()
メソッドによって文字列に変換されます。Objectには、内容ではなく識別情報が記述されています。このメソッドにより返される値は、
a
がnull
である場合を除き、Arrays.asList(a).toString()
により返される値に等しくなります。aがnullである場合は、null
が返されます。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
- 関連項目:
deepToString(Object[])
-
deepToString
指定された配列の「深層内容」の文字列表現を返します。 配列に要素以外の配列が含まれる場合、文字列表現にはその内容などが含まれます。 このメソッドは、多次元配列の文字列への変換用に設計されています。文字列表現は、角カッコ(「
[]
」)で囲まれた配列要素のリストで構成されます。 隣接する要素は、文字「,
」(カンマとそれに続く空白文字)で区切られます。 要素は、それ自体が配列でないかぎりString.valueOf(Object)
により文字列に変換されます。要素
e
がプリミティブ型の配列である場合、Arrays.toString(e)
の適切なオーバーロードを呼び出すことで文字列に変換されます。 要素e
が参照型の配列である場合、このメソッドを再帰的に呼び出すことで文字列に変換されます。無限の再帰を避けるため、指定された配列に自身が要素として含まれるか、1つまたは複数の配列レベルを介した自身への間接参照が含まれる場合、自己参照は文字列
「[...]」
に変換されます。 たとえば、自身への参照だけを含む配列は、「[[...]]」
として描画されます。指定された配列が
null
の場合、このメソッドは「null」
を返します。- パラメータ:
a
- 文字列表現を返す配列- 戻り値:
a
の文字列表現- 導入されたバージョン:
- 1.5
- 関連項目:
toString(Object[])
-
setAll
public static <T> void setAll(T[] array, IntFunction<? extends T> generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.apply(i));
- 型パラメータ:
T
- 配列の要素の型- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
parallelSetAll
public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。そのジェネレータ関数によって例外がスローされた場合は、
parallelSetAll
から非チェック例外がスローされ、配列は不確定な状態のままになります。- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.apply(i));
- 型パラメータ:
T
- 配列の要素の型- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
setAll
public static void setAll(int[] array, IntUnaryOperator generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsInt(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
parallelSetAll
public static void parallelSetAll(int[] array, IntUnaryOperator generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。そのジェネレータ関数によって例外がスローされた場合は、
parallelSetAll
から非チェック例外がスローされ、配列は不確定な状態のままになります。- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsInt(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
setAll
public static void setAll(long[] array, IntToLongFunction generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsLong(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
parallelSetAll
public static void parallelSetAll(long[] array, IntToLongFunction generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。そのジェネレータ関数によって例外がスローされた場合は、
parallelSetAll
から非チェック例外がスローされ、配列は不確定な状態のままになります。- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsLong(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
setAll
public static void setAll(double[] array, IntToDoubleFunction generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。そのジェネレータ関数によって例外がスローされた場合は、その例外が呼出し側に中継され、配列は不確定な状態のままになります。
- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .forEach(i -> array[i] = generator.applyAsDouble(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
parallelSetAll
public static void parallelSetAll(double[] array, IntToDoubleFunction generator)指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。そのジェネレータ関数によって例外がスローされた場合は、
parallelSetAll
から非チェック例外がスローされ、配列は不確定な状態のままになります。- APIのノート:
- ジェネレータ関数を使用して各要素をコンピュートする配列の部分範囲を並列に設定すると、次のように書くことができます:
IntStream.range(startInclusive, endExclusive) .parallel() .forEach(i -> array[i] = generator.applyAsDouble(i));
- パラメータ:
array
- 初期化される配列generator
- インデックスを受け入れ、その位置に必要な値を生成する関数- 例外:
NullPointerException
- そのジェネレータがnullの場合- 導入されたバージョン:
- 1.8
-
spliterator
public static <T> Spliterator<T> spliterator(T[] array)指定された配列のすべてに適用されるSpliterator
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- 型パラメータ:
T
- 要素の型- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- その配列の要素のスプリッテレータ
- 導入されたバージョン:
- 1.8
-
spliterator
public static <T> Spliterator<T> spliterator(T[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲に適用されるSpliterator
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- 型パラメータ:
T
- 要素の型- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- その配列の要素のスプリッテレータ
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfInt spliterator(int[] array)指定された配列のすべてに適用されるSpliterator.OfInt
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- その配列の要素のスプリッテレータ
- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲に適用されるSpliterator.OfInt
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- その配列の要素のスプリッテレータ
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfLong spliterator(long[] array)指定された配列のすべてに適用されるSpliterator.OfLong
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- 配列の要素のスプリッテレータ
- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲に適用されるSpliterator.OfLong
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- その配列の要素のスプリッテレータ
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfDouble spliterator(double[] array)指定された配列のすべてに適用されるSpliterator.OfDouble
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- その配列の要素のスプリッテレータ
- 導入されたバージョン:
- 1.8
-
spliterator
public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲に適用されるSpliterator.OfDouble
を返します。そのスプリッテレータは、
Spliterator.SIZED
、Spliterator.SUBSIZED
、Spliterator.ORDERED
、およびSpliterator.IMMUTABLE
を報告します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- その配列の要素のスプリッテレータ
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
stream
public static <T> Stream<T> stream(T[] array)指定された配列をソースとして使用して、逐次的なStream
を返します。- 型パラメータ:
T
- 配列の要素の型- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- 配列の
Stream
- 導入されたバージョン:
- 1.8
-
stream
public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲をソースとして使用して、逐次的なStream
を返します。- 型パラメータ:
T
- 配列の要素の型- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- 配列の範囲の
Stream
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
stream
public static IntStream stream(int[] array)指定された配列をソースとして使用して、逐次的なIntStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- 配列の
IntStream
- 導入されたバージョン:
- 1.8
-
stream
public static IntStream stream(int[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲をソースとして使用して、逐次的なIntStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- 配列の範囲の
IntStream
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
stream
public static LongStream stream(long[] array)指定された配列をソースとして使用して、逐次的なLongStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- 配列の
LongStream
- 導入されたバージョン:
- 1.8
-
stream
public static LongStream stream(long[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲をソースとして使用して、逐次的なLongStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- 配列の範囲の
LongStream
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
stream
public static DoubleStream stream(double[] array)指定された配列をソースとして使用して、逐次的なDoubleStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列- 戻り値:
- 配列の
DoubleStream
- 導入されたバージョン:
- 1.8
-
stream
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive)指定された配列の指定された範囲をソースとして使用して、逐次的なDoubleStream
を返します。- パラメータ:
array
- 使用中に変更されないと想定される配列startInclusive
- 適用される最初のインデックス(これを含む)endExclusive
- 適用される最後のインデックスの直後のインデックス- 戻り値:
- 配列の範囲の
DoubleStream
- 例外:
ArrayIndexOutOfBoundsException
-startInclusive
が負の場合、endExclusive
がstartInclusive
よりも小さい場合、またはendExclusive
が配列サイズよりも大きい場合- 導入されたバージョン:
- 1.8
-
compare
public static int compare(boolean[] a, boolean[] b)2つのboolean
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Boolean.compare(boolean, boolean)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(boolean[], boolean[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Boolean.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのboolean
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Boolean.compare(boolean, boolean)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(boolean[], int, int, boolean[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compare
public static int compare(byte[] a, byte[] b)2つのbyte
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Byte.compare(byte, byte)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], byte[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのbyte
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Byte.compare(byte, byte)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], int, int, byte[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(byte[] a, byte[] b)2つのbyte
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Byte.compareUnsigned(byte, byte)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], byte[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Byte.compareUnsigned(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)2つのbyte
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Byte.compareUnsigned(byte, byte)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(byte[], int, int, byte[], int, int)
を参照してください。)- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnullの場合- 導入されたバージョン:
- 9
-
compare
public static int compare(short[] a, short[] b)2つのshort
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Short.compare(short, short)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], short[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのshort
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Short.compare(short, short)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], int, int, short[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(short[] a, short[] b)2つのshort
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Short.compareUnsigned(short, short)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], short[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Short.compareUnsigned(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)2つのshort
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Short.compareUnsigned(short, short)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(short[], int, int, short[], int, int)
を参照してください。)- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnullの場合- 導入されたバージョン:
- 9
-
compare
public static int compare(char[] a, char[] b)2つのchar
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Character.compare(char, char)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(char[], char[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Character.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのchar
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Character.compare(char, char)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(char[], int, int, char[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Character.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compare
public static int compare(int[] a, int[] b)2つのint
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Integer.compare(int, int)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのint
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Integer.compare(int, int)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int, int, int[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(int[] a, int[] b)2つのint
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Integer.compareUnsigned(int, int)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Integer.compareUnsigned(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)2つのint
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Integer.compareUnsigned(int, int)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(int[], int, int, int[], int, int)
を参照してください。)- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnullの場合- 導入されたバージョン:
- 9
-
compare
public static int compare(long[] a, long[] b)2つのlong
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Long.compare(long, long)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], long[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのlong
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Long.compare(long, long)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], int, int, long[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(long[] a, long[] b)2つのlong
配列を辞書的に比較し、要素を数値的にunsignedとして扱います。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Long.compareUnsigned(long, long)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], long[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Long.compareUnsigned(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compareUnsigned
public static int compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)2つのlong
配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Long.compareUnsigned(long, long)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(long[], int, int, long[], int, int)
を参照してください。)- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnullの場合- 導入されたバージョン:
- 9
-
compare
public static int compare(float[] a, float[] b)2つのfloat
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Float.compare(float, float)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(float[], float[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Float.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのfloat
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Float.compare(float, float)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(float[], int, int, float[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Float.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compare
public static int compare(double[] a, double[] b)2つのdouble
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、
Double.compare(double, double)
のように、プレフィクスの長さであるそれぞれの配列内のインデックスで2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(double[], double[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。比較は
equals
と一貫しており、より具体的には、配列a
とb
については以下のとおりです:Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b); if (i >= 0 && i < Math.min(a.length, b.length)) return Double.compare(a[i], b[i]); return a.length - b.length;
- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 導入されたバージョン:
- 9
-
compare
public static int compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)指定された範囲にわたって2つのdouble
配列を辞書順に比較します。指定された範囲の2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、プレフィクスの長さであるそれぞれの配列内の相対インデックスで、2つの要素を
Double.compare(double, double)
のように比較した結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、mismatch(double[], int, int, double[], int, int)
を参照してください。)この比較は、
equals
と一貫しており、より具体的には、指定された範囲[aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ配列a
およびb
について:Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
- APIのノート:
このメソッドは次のように動作します:
int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return Double.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compare
public static <T extends Comparable<? super T>> int compare(T[] a, T[] b)比較可能な要素内の2つのObject
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、字句比較は、プレフィクスの長さであるそれぞれの配列内の索引
i
で型T
の2つの要素を比較した結果です:
それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は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)- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
compare
public static <T> int compare(T[] a, T[] b, Comparator<? super T> cmp)指定されたコンパレータを使用して、2つのObject
配列を辞書順に比較します。2つの配列が共通のプレフィクスを共有している場合、辞書編集の比較は、指定されたコンパレータと、プレフィクスの長さであるそれぞれの配列内のインデックスの2つの要素を比較した結果です。 それ以外の場合、一方の配列は他方の配列の適切なプレフィクスであり、辞書編集の比較は2つの配列の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、
mismatch(Object[], Object[])
を参照してください。)null
配列参照は、非null
配列参照よりも辞書編集的に小さいと見なされます。 2つのnull
配列参照は等しいとみなされます。- APIのノート:
このメソッドは、(非
null
配列参照の場合)のように動作します:int i = Arrays.mismatch(a, b, cmp); if (i >= 0 && i < Math.min(a.length, b.length)) return cmp.compare(a[i], b[i]); return a.length - b.length;
- 型パラメータ:
T
- 配列要素の型- パラメータ:
a
- 比較する最初の配列b
- 比較する2番目の配列cmp
- 配列要素を比較するコンパレータ- 戻り値:
- 第1配列と第2配列が等しく、同じ要素を同じ順序で含む場合は、値
0
; 第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 第1配列が第2配列よりも辞書的に大きい場合は、0
より大きい値 - 例外:
NullPointerException
- コンパレータがnull
の場合- 導入されたバージョン:
- 9
-
compare
public static <T> int compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)指定された範囲にわたって2つのObject
配列を辞書順に比較します。指定された範囲にわたって2つの配列が共通のプレフィクスを共有する場合、辞書編集の比較は、指定された比較器との比較の結果です。 それ以外の場合、一方の配列は他方の適切なプレフィクスであり、辞書編集の比較は2つの範囲の長さを比較した結果です。 (共通で適切なプレフィクスの定義については、
mismatch(Object[], int, int, Object[], int, int)
を参照してください。)- APIのノート:
このメソッドは、(非
null
配列要素の場合)のように動作します:int i = Arrays.mismatch(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex, cmp); if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex)) return cmp.compare(a[aFromIndex + i], b[bFromIndex + i]); return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
- 型パラメータ:
T
- 配列要素の型- パラメータ:
a
- 比較する最初の配列aFromIndex
- 比較される最初の配列の最初の要素のインデックス(inclusive)aToIndex
- 比較される最初の配列の最後の要素のインデックス(exclusive)b
- 比較する2番目の配列bFromIndex
- 比較される第2の配列内の第1の要素のインデックス(inclusive)bToIndex
- 比較される第2の配列内の最後の要素のインデックス(exclusive)cmp
- 配列要素を比較するコンパレータ- 戻り値:
- 指定された範囲で、第1および第2の配列が等しく、同じ順序で同じ要素を含む場合は、値
0
; 指定された範囲で、第1配列が第2配列よりも辞書的に小さい場合は、0
より小さい値; 指定された範囲で、第1配列が第2配列よりも辞書的に大きい場合は0
より大きい値 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- 配列またはコンパレータのいずれかがnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(boolean[] a, boolean[] b)2つのboolean
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。 インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。 一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
2つの非
null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、a
およびb
は、次の式がtrueである場合、適切なプレフィクスを共有します:a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
- パラメータ:
a
- 不一致がテストされる最初の配列b
- 不一致がテストされる第2の配列- 戻り値:
- 2つの配列間の最初の不一致のインデックス、それ以外の場合は
-1
。 - 例外:
NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)2つのboolean
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。 インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。 一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
指定された範囲[
aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ2つの非null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、指定された範囲[aFromIndex
,atoIndex
)および[bFromIndex
,btoIndex
)を各々持つa
およびb
は、次の式がtrueの場合適切なプレフィクスを共有します:(aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
- パラメータ:
a
- 不一致がテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 不一致がテストされる第2の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ
-1
。 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(byte[] a, byte[] b)2つのbyte
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。 インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。 一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
2つの非
null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、a
およびb
は、次の式がtrueである場合、適切なプレフィクスを共有します:a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
- パラメータ:
a
- 不一致がテストされる最初の配列b
- 不一致がテストされる第2の配列- 戻り値:
- 2つの配列間の最初の不一致のインデックス、それ以外の場合は
-1
。 - 例外:
NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)2つのbyte
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。 インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。 一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
指定された範囲[
aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ2つの非null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、指定された範囲[aFromIndex
,atoIndex
)および[bFromIndex
,btoIndex
)を各々持つa
およびb
は、次の式がtrueの場合適切なプレフィクスを共有します:(aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
- パラメータ:
a
- 不一致がテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 不一致がテストされる第2の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ
-1
。 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(char[] a, char[] b)2つのchar
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。 インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。 一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
2つの非
null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、a
およびb
は、次の式がtrueである場合、適切なプレフィクスを共有します:a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
- パラメータ:
a
- 不一致がテストされる最初の配列b
- 不一致がテストされる第2の配列- 戻り値:
- 2つの配列間の最初の不一致のインデックス、それ以外の場合は
-1
。 - 例外:
NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)2つのchar
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。 インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。 一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
指定された範囲[
aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ2つの非null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、指定された範囲[aFromIndex
,atoIndex
)および[bFromIndex
,btoIndex
)を各々持つa
およびb
は、次の式がtrueの場合適切なプレフィクスを共有します:(aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
- パラメータ:
a
- 不一致がテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 不一致がテストされる第2の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ
-1
。 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(short[] a, short[] b)2つのshort
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。 インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。 一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
2つの非
null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、a
およびb
は、次の式がtrueである場合、適切なプレフィクスを共有します:a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
- パラメータ:
a
- 不一致がテストされる最初の配列b
- 不一致がテストされる第2の配列- 戻り値:
- 2つの配列間の最初の不一致のインデックス、それ以外の場合は
-1
。 - 例外:
NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)2つのshort
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。 インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。 一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
指定された範囲[
aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ2つの非null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、指定された範囲[aFromIndex
,atoIndex
)および[bFromIndex
,btoIndex
)を各々持つa
およびb
は、次の式がtrueの場合適切なプレフィクスを共有します:(aToIndex - aFromIndex) != (bToIndex - bFromIndex) && Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex), b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
- パラメータ:
a
- 不一致がテストされる最初の配列aFromIndex
- テストされる最初の配列の最初の要素のインデックス(inclusive)aToIndex
- テストされる最初の配列の最後の要素のインデックス(exclusive)b
- 不一致がテストされる第2の配列bFromIndex
- テストされる第2の配列の第1の要素のインデックス(inclusive)bToIndex
- テストされるの2番目の配列の最後の要素のインデックス(exclusive)- 戻り値:
- 指定された範囲での2つの配列間の最初の不一致の相対インデックス。そうでなければ
-1
。 - 例外:
IllegalArgumentException
-aFromIndex > aToIndex
またはbFromIndex > bToIndex
の場合ArrayIndexOutOfBoundsException
-aFromIndex < 0 or aToIndex > a.length
またはbFromIndex < 0 or bToIndex > b.length
の場合NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(int[] a, int[] b)2つのint
配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。 インデックスは、小さい方の配列の長さ(inclusive)までの範囲にあります。2つの配列が共通のプレフィクスを共有する場合、返される索引は共通のプレフィクスの長さになり、それぞれの配列内のその索引にある2つの要素の間に不一致が存在します。 一方の配列が他方の適切なプレフィクスである場合、返されるインデックスはより小さい配列の長さであり、インデックスはより大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
2つの非
null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(a.length, b.length) && Arrays.equals(a, 0, pl, b, 0, pl) && a[pl] != b[pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。2つの非
null
配列、a
およびb
は、次の式がtrueである場合、適切なプレフィクスを共有します:a.length != b.length && Arrays.equals(a, 0, Math.min(a.length, b.length), b, 0, Math.min(a.length, b.length))
- パラメータ:
a
- 不一致がテストされる最初の配列b
- 不一致がテストされる第2の配列- 戻り値:
- 2つの配列間の最初の不一致のインデックス、それ以外の場合は
-1
。 - 例外:
NullPointerException
- いずれかの配列がnull
の場合- 導入されたバージョン:
- 9
-
mismatch
public static int mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)2つのint
配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。 インデックスは、小さい範囲の長さ(inclusive)までの範囲内にあります。指定された範囲で2つの配列が共通のプレフィクスを共有する場合、返される相対索引は共通プレフィクスの長さであり、それぞれの配列内の相対索引で2つの要素間に不一致が存在することになります。 一方の配列が他方の適切なプレフィクスである場合、指定された範囲にわたって返される相対索引はより小さい範囲の長さであり、相対索引はより大きな範囲の配列に対してのみ有効です。 それ以外の場合は、不一致はありません。
指定された範囲[
aFromIndex
、atoIndex
]および[bFromIndex
、btoIndex
]を持つ2つの非null
配列、a
およびb
は、次の式がtrueであれば、長さpl
の共通プレフィクスを共有します:pl >= 0 && pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) && Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) && a[aFromIndex + pl] != b[bFromIndex + pl]
0
の共通プレフィクス長は、各配列の最初の要素が不一致であることを示します。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
の場合
-