Java : Arrays (配列操作) - API使用例

Arrays (Java SE 16 & JDK 16)の使用例まとめです。
だいたいのメソッドを網羅済みです。
公式API仕様のおともにどうぞ。


概要

クラス構成

Arraysクラスには、

  • ソート
  • 検索
  • 比較

などなど、配列を操作するためのメソッドがいろいろとそろっています。

コード例として共通で使うクラス

本記事のコード例では、以下のクラスを共通で使います。
主に Comparator を必要とするAPIのためです。

// 2つの整数をもつクラスです。
class Pair {
    final int first;
    final int second;

    Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public String toString() {
        return "(%d, %d)".formatted(first, second);
    }
}

// Pairクラスを大小比較するためのクラスです。
class PairComparator implements Comparator<Pair> {
    @Override
    public int compare(Pair o1, Pair o2) {
        if (o1.first == o2.first) {
            return o1.second - o2.second;
        } else {
            return o1.first - o2.first;
        }
    }
}

メソッド

static <T> List<T> asList (T... a)

指定された配列に連動する固定サイズのリストを返します。

final List<String> list = Arrays.asList("aaa", "bbb", "ccc");
System.out.println(list); // [aaa, bbb, ccc]
// 配列を指定してもOKです。
final String[] array = {"aaa", "bbb", "ccc"};
final List<String> list = Arrays.asList(array);
System.out.println(list); // [aaa, bbb, ccc]
final List<Integer> list = Arrays.asList(1, 999, 12345);
System.out.println(list); // [1, 999, 12345]

static int binarySearch (byte[] a, byte key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値を検索します。

型が違うこと以外は、binarySearch(int[] a, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (byte[] a, int fromIndex, int toIndex, byte key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたbyte値の配列から指定された値の範囲を検索します。

型が違うこと以外は、binarySearch(int[] a, int fromIndex, int toIndex, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (char[] a, char key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値を検索します。

final char[] a = {'a', 'z', 'b', 'y', 'c', 'x'};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [a, b, c, x, y, z]

System.out.println(Arrays.binarySearch(a, 'a')); // 0
System.out.println(Arrays.binarySearch(a, 'b')); // 1
System.out.println(Arrays.binarySearch(a, 'c')); // 2

System.out.println(Arrays.binarySearch(a, 'x')); // 3
System.out.println(Arrays.binarySearch(a, 'y')); // 4
System.out.println(Arrays.binarySearch(a, 'z')); // 5

System.out.println(Arrays.binarySearch(a, 'g')); // -4

static int binarySearch (char[] a, int fromIndex, int toIndex, char key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたchar値の配列から指定された値の範囲を検索します。

final char[] a = {'a', 'z', 'b', 'y'};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [a, b, y, z]

System.out.println(Arrays.binarySearch(a, 0, 4, 'a')); // 0
System.out.println(Arrays.binarySearch(a, 0, 4, 'b')); // 1
System.out.println(Arrays.binarySearch(a, 0, 4, 'y')); // 2
System.out.println(Arrays.binarySearch(a, 0, 4, 'z')); // 3

System.out.println(Arrays.binarySearch(a, 0, 4, 'g')); // -3

System.out.println(Arrays.binarySearch(a, 1, 4, 'a')); // -2
System.out.println(Arrays.binarySearch(a, 1, 4, 'b')); // 1
System.out.println(Arrays.binarySearch(a, 1, 4, 'y')); // 2
System.out.println(Arrays.binarySearch(a, 1, 4, 'z')); // 3

System.out.println(Arrays.binarySearch(a, 0, 3, 'a')); // 0
System.out.println(Arrays.binarySearch(a, 0, 3, 'b')); // 1
System.out.println(Arrays.binarySearch(a, 0, 3, 'y')); // 2
System.out.println(Arrays.binarySearch(a, 0, 3, 'z')); // -4

static int binarySearch (double[] a, double key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値を検索します。

型が違うこと以外は、binarySearch(int[] a, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (double[] a, int fromIndex, int toIndex, double key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたdouble値の配列から指定された値の範囲を検索します。

型が違うこと以外は、binarySearch(int[] a, int fromIndex, int toIndex, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (float[] a, float key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値を検索します。

型が違うこと以外は、binarySearch(int[] a, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (float[] a, int fromIndex, int toIndex, float key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたfloat値の配列から指定された値の範囲を検索します。

型が違うこと以外は、binarySearch(int[] a, int fromIndex, int toIndex, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (int[] a, int key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値を検索します。

final int[] a = {1, 10, 2, 20, 3, 30};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [1, 2, 3, 10, 20, 30]

System.out.println(Arrays.binarySearch(a, 1)); // 0
System.out.println(Arrays.binarySearch(a, 2)); // 1
System.out.println(Arrays.binarySearch(a, 3)); // 2

System.out.println(Arrays.binarySearch(a, 10)); // 3
System.out.println(Arrays.binarySearch(a, 20)); // 4
System.out.println(Arrays.binarySearch(a, 30)); // 5

System.out.println(Arrays.binarySearch(a, 999)); // -7

static int binarySearch (int[] a, int fromIndex, int toIndex, int key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたint値の配列から指定された値の範囲を検索します。

final int[] a = {1, 10, 2, 20};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [1, 2, 10, 20]

System.out.println(Arrays.binarySearch(a, 0, 4, 1)); // 0
System.out.println(Arrays.binarySearch(a, 0, 4, 2)); // 1
System.out.println(Arrays.binarySearch(a, 0, 4, 10)); // 2
System.out.println(Arrays.binarySearch(a, 0, 4, 20)); // 3

System.out.println(Arrays.binarySearch(a, 0, 4, 999)); // -5

System.out.println(Arrays.binarySearch(a, 1, 4, 1)); // -2
System.out.println(Arrays.binarySearch(a, 1, 4, 2)); // 1
System.out.println(Arrays.binarySearch(a, 1, 4, 10)); // 2
System.out.println(Arrays.binarySearch(a, 1, 4, 20)); // 3

System.out.println(Arrays.binarySearch(a, 0, 3, 1)); // 0
System.out.println(Arrays.binarySearch(a, 0, 3, 2)); // 1
System.out.println(Arrays.binarySearch(a, 0, 3, 10)); // 2
System.out.println(Arrays.binarySearch(a, 0, 3, 20)); // -4

static int binarySearch (long[] a, int fromIndex, int toIndex, long key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値の範囲を検索します。

型が違うこと以外は、binarySearch(int[] a, int fromIndex, int toIndex, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (long[] a, long key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたlong値の配列から指定された値を検索します。

型が違うこと以外は、binarySearch(int[] a, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (short[] a, int fromIndex, int toIndex, short key)

バイナリ・サーチ・アルゴリズムを使用して、指定されたshort値の配列から指定された値の範囲を検索します。

型が違うこと以外は、binarySearch(int[] a, int fromIndex, int toIndex, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (short[] a, short key)

バイナリ・サーチ・アルゴリズムを使用し、指定されたshort値の配列から指定された値を検索します。

型が違うこと以外は、binarySearch(int[] a, int key)と使い方は同じです。
API使用例はそちらをご参照ください。

static int binarySearch (Object[] a, int fromIndex, int toIndex, Object key)

バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。

final String[] a = {"a", "z", "b", "y"};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [a, b, y, z]

System.out.println(Arrays.binarySearch(a, 0, 4, "a")); // 0
System.out.println(Arrays.binarySearch(a, 0, 4, "b")); // 1
System.out.println(Arrays.binarySearch(a, 0, 4, "y")); // 2
System.out.println(Arrays.binarySearch(a, 0, 4, "z")); // 3

System.out.println(Arrays.binarySearch(a, 0, 4, "g")); // -3

System.out.println(Arrays.binarySearch(a, 1, 4, "a")); // -2
System.out.println(Arrays.binarySearch(a, 1, 4, "b")); // 1
System.out.println(Arrays.binarySearch(a, 1, 4, "y")); // 2
System.out.println(Arrays.binarySearch(a, 1, 4, "z")); // 3

System.out.println(Arrays.binarySearch(a, 0, 3, "a")); // 0
System.out.println(Arrays.binarySearch(a, 0, 3, "b")); // 1
System.out.println(Arrays.binarySearch(a, 0, 3, "y")); // 2
System.out.println(Arrays.binarySearch(a, 0, 3, "z")); // -4

static int binarySearch (Object[] a, Object key)

バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。

final String[] a = {"a", "z", "b", "y", "c", "x"};

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a);
System.out.println(Arrays.toString(a)); // [a, b, c, x, y, z]

System.out.println(Arrays.binarySearch(a, "a")); // 0
System.out.println(Arrays.binarySearch(a, "b")); // 1
System.out.println(Arrays.binarySearch(a, "c")); // 2

System.out.println(Arrays.binarySearch(a, "x")); // 3
System.out.println(Arrays.binarySearch(a, "y")); // 4
System.out.println(Arrays.binarySearch(a, "z")); // 5

System.out.println(Arrays.binarySearch(a, "g")); // -4

static <T> int binarySearch (T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

バイナリ・サーチ・アルゴリズムを使用して、指定された配列の範囲から指定されたオブジェクトを検索します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 1),
        new Pair(2, 2),
        new Pair(1, 1),
        new Pair(1, 2)
};

final var c = new PairComparator();

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a, c);
System.out.println(Arrays.toString(a)); // [(1, 1), (1, 2), (2, 1), (2, 2)]

System.out.println(Arrays.binarySearch(a, 0, 4, new Pair(1, 1), c)); // 0
System.out.println(Arrays.binarySearch(a, 0, 4, new Pair(1, 2), c)); // 1
System.out.println(Arrays.binarySearch(a, 0, 4, new Pair(2, 1), c)); // 2
System.out.println(Arrays.binarySearch(a, 0, 4, new Pair(2, 2), c)); // 3

System.out.println(Arrays.binarySearch(a, 0, 4, new Pair(3, 3), c)); // -5

System.out.println(Arrays.binarySearch(a, 1, 4, new Pair(1, 1), c)); // -2
System.out.println(Arrays.binarySearch(a, 1, 4, new Pair(1, 2), c)); // 1
System.out.println(Arrays.binarySearch(a, 1, 4, new Pair(2, 1), c)); // 2
System.out.println(Arrays.binarySearch(a, 1, 4, new Pair(2, 2), c)); // 3

System.out.println(Arrays.binarySearch(a, 0, 3, new Pair(1, 1), c)); // 0
System.out.println(Arrays.binarySearch(a, 0, 3, new Pair(1, 2), c)); // 1
System.out.println(Arrays.binarySearch(a, 0, 3, new Pair(2, 1), c)); // 2
System.out.println(Arrays.binarySearch(a, 0, 3, new Pair(2, 2), c)); // -4

static <T> int binarySearch (T[] a, T key, Comparator<? super T> c)

バイナリ・サーチ・アルゴリズムを使用して、指定された配列から指定されたオブジェクトを検索します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 1),
        new Pair(2, 2),
        new Pair(1, 1),
        new Pair(1, 2)
};

final var c = new PairComparator();

// 対象となる配列はソートされていることが必要です。
Arrays.sort(a, c);
System.out.println(Arrays.toString(a)); // [(1, 1), (1, 2), (2, 1), (2, 2)]

System.out.println(Arrays.binarySearch(a, new Pair(1, 1), c)); // 0
System.out.println(Arrays.binarySearch(a, new Pair(1, 2), c)); // 1
System.out.println(Arrays.binarySearch(a, new Pair(2, 1), c)); // 2
System.out.println(Arrays.binarySearch(a, new Pair(2, 2), c)); // 3

System.out.println(Arrays.binarySearch(a, new Pair(3, 3), c)); // -5

static int compare (boolean[] a, boolean[] b)

2つのboolean配列を辞書順に比較します。

final boolean[] a = {false, true, false};
final boolean[] b = {true, false, true};

System.out.println(Arrays.compare(a, a)); // 0
System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1
final boolean[] a = {true, true, true};
final boolean[] b = {true, true};

System.out.println(Arrays.compare(a, b)); // 1
System.out.println(Arrays.compare(b, a)); // -1
final boolean[] a = {false, false, false};
final boolean[] b = {true, true};

System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1

static int compare (boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのboolean配列を辞書順に比較します。

final boolean[] a = {true, true, false, false, true, true};
final boolean[] b = {false, false, true, true, false, false};

{
    System.out.println(Arrays.compare(a, 0, 6, a, 0, 6)); // 0
    System.out.println(Arrays.compare(a, 0, 6, b, 0, 6)); // 1
    System.out.println(Arrays.compare(b, 0, 6, a, 0, 6)); // -1
}

{
    System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 4))); // [true, true, false, false]
    System.out.println(Arrays.toString(Arrays.copyOfRange(b, 2, 6))); // [true, true, false, false]

    System.out.println(Arrays.compare(a, 0, 4, b, 2, 6)); // 0

    System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 4))); // [false, false]
    System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 2))); // [false, false]
    System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [false, false]

    System.out.println(Arrays.compare(a, 2, 4, b, 0, 2)); // 0
    System.out.println(Arrays.compare(a, 2, 4, b, 4, 6)); // 0
}

static int compare (byte[] a, byte[] b)

2つのbyte配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのbyte配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (char[] a, char[] b)

2つのchar配列を辞書順に比較します。

final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] b = {'c', 'd', 'e', 'f', 'a', 'b'};

System.out.println(Arrays.compare(a, a)); // 0
System.out.println(Arrays.compare(a, b)); // -2
System.out.println(Arrays.compare(b, a)); // 2
final char[] a = {'a', 'a', 'a'};
final char[] b = {'a', 'a'};

System.out.println(Arrays.compare(a, b)); // 1
System.out.println(Arrays.compare(b, a)); // -1
final char[] a = {'a', 'a', 'a'};
final char[] b = {'b', 'b'};

System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1

static int compare (char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのchar配列を辞書順に比較します。

final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] b = {'c', 'd', 'e', 'f', 'a', 'b'};

System.out.println(Arrays.compare(a, 0, 6, a, 0, 6)); // 0
System.out.println(Arrays.compare(a, 0, 6, b, 0, 6)); // -2
System.out.println(Arrays.compare(b, 0, 6, a, 0, 6)); // 2

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [c, d, e, f]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [c, d, e, f]
System.out.println(Arrays.compare(a, 2, 6, b, 0, 4)); // 0

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [a, b]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [a, b]
System.out.println(Arrays.compare(a, 0, 2, b, 4, 6)); // 0

static int compare (double[] a, double[] b)

2つのdouble配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのdouble配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (float[] a, float[] b)

2つのfloat配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのfloat配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (int[] a, int[] b)

2つのint配列を辞書順に比較します。

final int[] a = {0, 1, 2, 3, 4, 5};
final int[] b = {2, 3, 4, 5, 0, 1};

System.out.println(Arrays.compare(a, a)); // 0
System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1
final int[] a = {1, 1, 1};
final int[] b = {1, 1};

System.out.println(Arrays.compare(a, b)); // 1
System.out.println(Arrays.compare(b, a)); // -1
final int[] a = {0, 0, 0};
final int[] b = {1, 1};

System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1

static int compare (int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのint配列を辞書順に比較します。

final int[] a = {0, 1, 2, 3, 4, 5};
final int[] b = {2, 3, 4, 5, 0, 1};

System.out.println(Arrays.compare(a, 0, 6, a, 0, 6)); // 0
System.out.println(Arrays.compare(a, 0, 6, b, 0, 6)); // -1
System.out.println(Arrays.compare(b, 0, 6, a, 0, 6)); // 1

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [2, 3, 4, 5]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [2, 3, 4, 5]
System.out.println(Arrays.compare(a, 2, 6, b, 0, 4)); // 0

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [0, 1]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [0, 1]
System.out.println(Arrays.compare(a, 0, 2, b, 4, 6)); // 0

static int compare (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのlong配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (long[] a, long[] b)

2つのlong配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのshort配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compare (short[] a, short[] b)

2つのshort配列を辞書順に比較します。

型が違うこと以外は、compare(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T extends Comparable<? super T>> int compare (T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)

指定された範囲にわたって2つのObject配列を辞書順に比較します。

// StringクラスはComparableを実装しています。
final String[] a = {"aa", "bb", "cc", "dd", "ee", "ff"};
final String[] b = {"cc", "dd", "ee", "ff", "aa", "bb"};

System.out.println(Arrays.compare(a, 0, 6, a, 0, 6)); // 0
System.out.println(Arrays.compare(a, 0, 6, b, 0, 6)); // -2
System.out.println(Arrays.compare(b, 0, 6, a, 0, 6)); // 2

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [cc, dd, ee, ff]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [cc, dd, ee, ff]
System.out.println(Arrays.compare(a, 2, 6, b, 0, 4)); // 0

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [aa, bb]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [aa, bb]
System.out.println(Arrays.compare(a, 0, 2, b, 4, 6)); // 0

static <T> int compare (T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)

指定された範囲にわたって2つのObject配列を辞書順に比較します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final Pair[] b = {
        new Pair(0, 2), new Pair(1, 0), new Pair(1, 1),
        new Pair(1, 2), new Pair(0, 0), new Pair(0, 1)};

final var cmp = new PairComparator();

System.out.println(Arrays.compare(a, 0, 6, a, 0, 6, cmp)); // 0
System.out.println(Arrays.compare(a, 0, 6, b, 0, 6, cmp)); // -2
System.out.println(Arrays.compare(b, 0, 6, a, 0, 6, cmp)); // 2

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [(0, 2), (1, 0), (1, 1), (1, 2)]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [(0, 2), (1, 0), (1, 1), (1, 2)]
System.out.println(Arrays.compare(a, 2, 6, b, 0, 4, cmp)); // 0

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [(0, 0), (0, 1)]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [(0, 0), (0, 1)]
System.out.println(Arrays.compare(a, 0, 2, b, 4, 6, cmp)); // 0

static <T extends Comparable<? super T>> int compare (T[] a, T[] b)

比較可能な要素内の2つのObject配列を辞書順に比較します。

// StringクラスはComparableを実装しています。
final String[] a = {"aa", "bb", "cc", "dd", "ee", "ff"};
final String[] b = {"cc", "dd", "ee", "ff", "aa", "bb"};

System.out.println(Arrays.compare(a, a)); // 0
System.out.println(Arrays.compare(a, b)); // -2
System.out.println(Arrays.compare(b, a)); // 2
final String[] a = {"aa", "aa", "aa"};
final String[] b = {"aa", "aa"};

System.out.println(Arrays.compare(a, b)); // 1
System.out.println(Arrays.compare(b, a)); // -1
final String[] a = {"aa", "aa", "aa"};
final String[] b = {"bb", "bb"};

System.out.println(Arrays.compare(a, b)); // -1
System.out.println(Arrays.compare(b, a)); // 1

static <T> int compare (T[] a, T[] b, Comparator<? super T> cmp)

指定されたコンパレータを使用して、2つのObject配列を辞書順に比較します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final Pair[] b = {
        new Pair(0, 2), new Pair(1, 0), new Pair(1, 1),
        new Pair(1, 2), new Pair(0, 0), new Pair(0, 1)};

final var cmp = new PairComparator();

System.out.println(Arrays.compare(a, a, cmp)); // 0
System.out.println(Arrays.compare(a, b, cmp)); // -2
System.out.println(Arrays.compare(b, a, cmp)); // 2
final Pair[] a = {new Pair(0, 0), new Pair(0, 0), new Pair(0, 0)};
final Pair[] b = {new Pair(0, 0), new Pair(0, 0)};
final var cmp = new PairComparator();

System.out.println(Arrays.compare(a, b, cmp)); // 1
System.out.println(Arrays.compare(b, a, cmp)); // -1
final Pair[] a = {new Pair(0, 0), new Pair(0, 0), new Pair(0, 0)};
final Pair[] b = {new Pair(0, 1), new Pair(0, 1)};
final var cmp = new PairComparator();

System.out.println(Arrays.compare(a, b, cmp)); // -1
System.out.println(Arrays.compare(b, a, cmp)); // 1

static int compareUnsigned (byte[] a, byte[] b)

2つのbyte配列を辞書的に比較し、要素を数値的にunsignedとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compareUnsigned (byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)

2つのbyte配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compareUnsigned (int[] a, int[] b)

2つのint配列を辞書的に比較し、要素を数値的にunsignedとして扱います。

要素をunsignedとして扱う以外は compare(int[] a, int[] b) と同じになります。
API使用例はそちらもご参照ください。

final int[] a = {1, 1, 1};
final int[] b = {-1, -1, -1};

// -1は正の数の0xffffffffとして比較します。
System.out.println(Arrays.compareUnsigned(a, b)); // -1

// -1は負数として比較します。
System.out.println(Arrays.compare(a, b)); // 1

static int compareUnsigned (int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

2つのint配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。

要素をunsignedとして扱う以外は compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) と同じになります。
API使用例はそちらもご参照ください。

final int[] a = {1, 1, 1};
final int[] b = {-1, -1, -1};

// -1 は正の数の0xffffffffとして比較します。
System.out.println(Arrays.compareUnsigned(a, 0, 3, b, 0, 3)); // -1

// -1 は負数として比較します。
System.out.println(Arrays.compare(a, 0, 3, b, 0, 3)); // 1

static int compareUnsigned (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)

2つのlong配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compareUnsigned (long[] a, long[] b)

2つのlong配列を辞書的に比較し、要素を数値的にunsignedとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compareUnsigned (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)

2つのshort配列を指定された範囲で辞書的に比較し、要素を数値で符号なしとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int compareUnsigned (short[] a, short[] b)

2つのshort配列を辞書的に比較し、要素を数値的にunsignedとして扱います。

型が違うこと以外は、compareUnsigned(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean[] copyOf (boolean[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかfalseでパディングします。

final boolean[] original = {true, false, true, false};
System.out.println(Arrays.toString(original)); // [true, false, true, false]

final boolean[] copy1 = Arrays.copyOf(original, 4);
System.out.println(Arrays.toString(copy1)); // [true, false, true, false]

final boolean[] copy2 = Arrays.copyOf(original, 3);
System.out.println(Arrays.toString(copy2)); // [true, false, true]

final boolean[] copy3 = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(copy3)); // [true, false]

final boolean[] copy4 = Arrays.copyOf(original, 6);
System.out.println(Arrays.toString(copy4)); // [true, false, true, false, false, false]

static byte[] copyOf (byte[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

型が違うこと以外は、copyOf(int[] original, int newLength)と使い方は同じです。
API使用例はそちらをご参照ください。

static char[] copyOf (char[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnull文字でパディングします。

final char[] original = {'a', 'b', 'c', 'd'};
System.out.println(Arrays.toString(original)); // [a, b, c, d]

final char[] copy1 = Arrays.copyOf(original, 4);
System.out.println(Arrays.toString(copy1)); // [a, b, c, d]

final char[] copy2 = Arrays.copyOf(original, 3);
System.out.println(Arrays.toString(copy2)); // [a, b, c]

final char[] copy3 = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(copy3)); // [a, b]

final char[] copy4 = Arrays.copyOf(original, 6);
System.out.println(Arrays.toString(copy4)); // [a, b, c, d,  ,  ]

static double[] copyOf (double[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

型が違うこと以外は、copyOf(int[] original, int newLength)と使い方は同じです。
API使用例はそちらをご参照ください。

static float[] copyOf (float[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

型が違うこと以外は、copyOf(int[] original, int newLength)と使い方は同じです。
API使用例はそちらをご参照ください。

static int[] copyOf (int[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

final int[] original = {1, 2, 3, 4};
System.out.println(Arrays.toString(original)); // [1, 2, 3, 4]

final int[] copy1 = Arrays.copyOf(original, 4);
System.out.println(Arrays.toString(copy1)); // [1, 2, 3, 4]

final int[] copy2 = Arrays.copyOf(original, 3);
System.out.println(Arrays.toString(copy2)); // [1, 2, 3]

final int[] copy3 = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(copy3)); // [1, 2]

final int[] copy4 = Arrays.copyOf(original, 6);
System.out.println(Arrays.toString(copy4)); // [1, 2, 3, 4, 0, 0]

static long[] copyOf (long[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

型が違うこと以外は、copyOf(int[] original, int newLength)と使い方は同じです。
API使用例はそちらをご参照ください。

static short[] copyOf (short[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかゼロでパディングします。

型が違うこと以外は、copyOf(int[] original, int newLength)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> T[] copyOf (T[] original, int newLength)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。

final String[] original = {"aa", "bb", "cc", "dd"};
System.out.println(Arrays.toString(original)); // [aa, bb, cc, dd]

final String[] copy1 = Arrays.copyOf(original, 4);
System.out.println(Arrays.toString(copy1)); // [aa, bb, cc, dd]

final String[] copy2 = Arrays.copyOf(original, 3);
System.out.println(Arrays.toString(copy2)); // [aa, bb, cc]

final String[] copy3 = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(copy3)); // [aa, bb]

final String[] copy4 = Arrays.copyOf(original, 6);
System.out.println(Arrays.toString(copy4)); // [aa, bb, cc, dd, null, null]
// コピー先の要素のインスタンスは同じになります。
// つまり要素が複製(clone)されているわけではありません。
final String[] original = {"aa", "bb"};
final String[] copy = Arrays.copyOf(original, 2);

System.out.println(original[0] == copy[0]); // true
System.out.println(original[1] == copy[1]); // true

static <T, U> T[] copyOf (U[] original, int newLength, Class<? extends T[]> newType)

指定された配列をコピーし、そのコピーが指定された長さになるように、必要に応じて切り詰めるかnullでパディングします。

final CharSequence[] original = {"aa", "bb", "cc", "dd"};
System.out.println(Arrays.toString(original)); // [aa, bb, cc, dd]

final String[] copy1 = Arrays.copyOf(original, 4, String[].class);
System.out.println(Arrays.toString(copy1)); // [aa, bb, cc, dd]

final String[] copy2 = Arrays.copyOf(original, 3, String[].class);
System.out.println(Arrays.toString(copy2)); // [aa, bb, cc]

final String[] copy3 = Arrays.copyOf(original, 2, String[].class);
System.out.println(Arrays.toString(copy3)); // [aa, bb]

final String[] copy4 = Arrays.copyOf(original, 6, String[].class);
System.out.println(Arrays.toString(copy4)); // [aa, bb, cc, dd, null, null]

static boolean[] copyOfRange (boolean[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

final boolean[] original = {true, false, true, false};
System.out.println(Arrays.toString(original)); // [true, false, true, false]

final boolean[] copy1 = Arrays.copyOfRange(original, 0, 4);
System.out.println(Arrays.toString(copy1)); // [true, false, true, false]

final boolean[] copy2 = Arrays.copyOfRange(original, 0, 3);
System.out.println(Arrays.toString(copy2)); // [true, false, true]

final boolean[] copy3 = Arrays.copyOfRange(original, 0, 2);
System.out.println(Arrays.toString(copy3)); // [true, false]

final boolean[] copy4 = Arrays.copyOfRange(original, 0, 6);
System.out.println(Arrays.toString(copy4)); // [true, false, true, false, false, false]

final boolean[] copy5 = Arrays.copyOfRange(original, 1, 4);
System.out.println(Arrays.toString(copy5)); // [false, true, false]

final boolean[] copy6 = Arrays.copyOfRange(original, 2, 4);
System.out.println(Arrays.toString(copy6)); // [true, false]

static byte[] copyOfRange (byte[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

型が違うこと以外は、copyOfRange(int[] original, int from, int to)と使い方は同じです。
API使用例はそちらをご参照ください。

static char[] copyOfRange (char[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

final char[] original = {'a', 'b', 'c', 'd'};
System.out.println(Arrays.toString(original)); // [a, b, c, d]

final char[] copy1 = Arrays.copyOfRange(original, 0, 4);
System.out.println(Arrays.toString(copy1)); // [a, b, c, d]

final char[] copy2 = Arrays.copyOfRange(original, 0, 3);
System.out.println(Arrays.toString(copy2)); // [a, b, c]

final char[] copy3 = Arrays.copyOfRange(original, 0, 2);
System.out.println(Arrays.toString(copy3)); // [a, b]

final char[] copy4 = Arrays.copyOfRange(original, 0, 6);
System.out.println(Arrays.toString(copy4)); // [a, b, c, d,  ,  ]

final char[] copy5 = Arrays.copyOfRange(original, 1, 4);
System.out.println(Arrays.toString(copy5)); // [b, c, d]

final char[] copy6 = Arrays.copyOfRange(original, 2, 4);
System.out.println(Arrays.toString(copy6)); // [c, d]

static double[] copyOfRange (double[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

型が違うこと以外は、copyOfRange(int[] original, int from, int to)と使い方は同じです。
API使用例はそちらをご参照ください。

static float[] copyOfRange (float[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

型が違うこと以外は、copyOfRange(int[] original, int from, int to)と使い方は同じです。
API使用例はそちらをご参照ください。

static int[] copyOfRange (int[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

final int[] original = {1, 2, 3, 4};
System.out.println(Arrays.toString(original)); // [1, 2, 3, 4]

final int[] copy1 = Arrays.copyOfRange(original, 0, 4);
System.out.println(Arrays.toString(copy1)); // [1, 2, 3, 4]

final int[] copy2 = Arrays.copyOfRange(original, 0, 3);
System.out.println(Arrays.toString(copy2)); // [1, 2, 3]

final int[] copy3 = Arrays.copyOfRange(original, 0, 2);
System.out.println(Arrays.toString(copy3)); // [1, 2]

final int[] copy4 = Arrays.copyOfRange(original, 0, 6);
System.out.println(Arrays.toString(copy4)); // [1, 2, 3, 4, 0, 0]

final int[] copy5 = Arrays.copyOfRange(original, 1, 4);
System.out.println(Arrays.toString(copy5)); // [2, 3, 4]

final int[] copy6 = Arrays.copyOfRange(original, 2, 4);
System.out.println(Arrays.toString(copy6)); // [3, 4]

static long[] copyOfRange (long[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

型が違うこと以外は、copyOfRange(int[] original, int from, int to)と使い方は同じです。
API使用例はそちらをご参照ください。

static short[] copyOfRange (short[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

型が違うこと以外は、copyOfRange(int[] original, int from, int to)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> T[] copyOfRange (T[] original, int from, int to)

指定された配列の指定された範囲を新しい配列にコピーします。

final String[] original = {"aa", "bb", "cc", "dd"};
System.out.println(Arrays.toString(original)); // [aa, bb, cc, dd]

final String[] copy1 = Arrays.copyOfRange(original, 0, 4);
System.out.println(Arrays.toString(copy1)); // [aa, bb, cc, dd]

final String[] copy2 = Arrays.copyOfRange(original, 0, 3);
System.out.println(Arrays.toString(copy2)); // [aa, bb, cc]

final String[] copy3 = Arrays.copyOfRange(original, 0, 2);
System.out.println(Arrays.toString(copy3)); // [aa, bb]

final String[] copy4 = Arrays.copyOfRange(original, 0, 6);
System.out.println(Arrays.toString(copy4)); // [aa, bb, cc, dd, null, null]

final String[] copy5 = Arrays.copyOfRange(original, 1, 4);
System.out.println(Arrays.toString(copy5)); // [bb, cc, dd]

final String[] copy6 = Arrays.copyOfRange(original, 2, 4);
System.out.println(Arrays.toString(copy6)); // [cc, dd]
// コピー先の要素のインスタンスは同じになります。
// つまり要素が複製(clone)されているわけではありません。
final String[] original = {"aa", "bb"};
final String[] copy = Arrays.copyOfRange(original, 0, 2);

System.out.println(original[0] == copy[0]); // true
System.out.println(original[1] == copy[1]); // true

static <T, U> T[] copyOfRange (U[] original, int from, int to, Class<? extends T[]> newType)

指定された配列の指定された範囲を新しい配列にコピーします。

final CharSequence[] original = {"aa", "bb", "cc", "dd"};
System.out.println(Arrays.toString(original)); // [aa, bb, cc, dd]

final String[] copy1 = Arrays.copyOfRange(original, 0, 4, String[].class);
System.out.println(Arrays.toString(copy1)); // [aa, bb, cc, dd]

final String[] copy2 = Arrays.copyOfRange(original, 0, 3, String[].class);
System.out.println(Arrays.toString(copy2)); // [aa, bb, cc]

final String[] copy3 = Arrays.copyOfRange(original, 0, 2, String[].class);
System.out.println(Arrays.toString(copy3)); // [aa, bb]

final String[] copy4 = Arrays.copyOfRange(original, 0, 6, String[].class);
System.out.println(Arrays.toString(copy4)); // [aa, bb, cc, dd, null, null]

final String[] copy5 = Arrays.copyOfRange(original, 1, 4, String[].class);
System.out.println(Arrays.toString(copy5)); // [bb, cc, dd]

final String[] copy6 = Arrays.copyOfRange(original, 2, 4, String[].class);
System.out.println(Arrays.toString(copy6)); // [cc, dd]

static boolean deepEquals (Object[] a1, Object[] a2)

2つの指定された配列が相互に深層で等価な場合、trueを返します。

final Object[] nestA = {1, 2, 3};
final Object[] a = {10, 20, nestA, 30, 40};

System.out.println(Arrays.deepToString(a)); // [10, 20, [1, 2, 3], 30, 40]

final Object[] nestB = {1, 2, 3};
final Object[] b = {10, 20, nestB, 30, 40};

System.out.println(Arrays.deepToString(a)); // [10, 20, [1, 2, 3], 30, 40]

System.out.println(Arrays.deepEquals(a, b)); // true
System.out.println(Arrays.equals(a, b)); // false

static int deepHashCode (Object[] a)

指定された配列の「深層内容」に基づくハッシュ・コードを返します。

final Object[] nestA = {1, 2, 3};
final Object[] a = {10, 20, nestA, 30, 40};

System.out.println(Arrays.deepToString(a)); // [10, 20, [1, 2, 3], 30, 40]

final Object[] nestB = {1, 2, 3};
final Object[] b = {10, 20, nestB, 30, 40};

System.out.println(Arrays.deepToString(a)); // [10, 20, [1, 2, 3], 30, 40]

System.out.println(Arrays.deepHashCode(a)); // 68076288
System.out.println(Arrays.deepHashCode(b)); // 68076288

System.out.println(Arrays.hashCode(a)); // 1313814990
System.out.println(Arrays.hashCode(b)); // -182832654

static String deepToString (Object[] a)

指定された配列の「深層内容」の文字列表現を返します。

final Object[] nest = {1, 2, 3};
final Object[] a = {10, 20, nest, 30, 40};

System.out.println(Arrays.deepToString(a)); // [10, 20, [1, 2, 3], 30, 40]
System.out.println(Arrays.toString(a)); // [10, 20, [Ljava.lang.Object;@4e0b6f09, 30, 40]

static boolean equals (boolean[] a, boolean[] a2)

指定された2つのboolean値の配列が互いに同等である場合にtrueを返します。

final boolean[] a = {true, true, true};
final boolean[] a2 = {true, true, true};

System.out.println(Arrays.equals(a, a2)); // true
final boolean[] a = {false, true, false};
final boolean[] a2 = {true, false, true};

System.out.println(Arrays.equals(a, a2)); // false
final boolean[] a = {true, true, true};
final boolean[] a2 = {true, true};

System.out.println(Arrays.equals(a, a2)); // false

static boolean equals (boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)

ブール値の指定された2つの配列が、指定された範囲にわたって、互いにequalの場合にtrueを返します。

final boolean[] a = {true, true, false, false, true, true};
final boolean[] b = {false, false, true, true, false, false};

System.out.println(Arrays.equals(a, 0, 6, b, 0, 6)); // false

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 4))); // [true, true, false, false]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 2, 6))); // [true, true, false, false]
System.out.println(Arrays.equals(a, 0, 4, b, 2, 6)); // true

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 4))); // [false, false]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 2))); // [false, false]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [false, false]
System.out.println(Arrays.equals(a, 2, 4, b, 0, 2)); // true
System.out.println(Arrays.equals(a, 2, 4, b, 4, 6)); // true

static boolean equals (byte[] a, byte[] a2)

指定された2つのbyte値の配列が互いに同等である場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int[] a2)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)

指定された2つのバイトの配列が、指定された範囲で互いにequalの場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (char[] a, char[] a2)

指定された2つのchar値の配列が互いに同等である場合にtrueを返します。

final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] a2 = {'a', 'b', 'c', 'd', 'e', 'f'};

System.out.println(Arrays.equals(a, a2)); // true
final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] a2 = {'c', 'd', 'e', 'f', 'a', 'b'};

System.out.println(Arrays.equals(a, a2)); // false
final char[] a = {'a', 'a', 'a'};
final char[] a2 = {'a', 'a'};

System.out.println(Arrays.equals(a, a2)); // false

static boolean equals (char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)

指定された2つの文字配列が、指定された範囲にわたってequalである場合にtrueを返します。

final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] b = {'c', 'd', 'e', 'f', 'a', 'b'};

System.out.println(Arrays.equals(a, 0, 6, b, 0, 6)); // false

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [c, d, e, f]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [c, d, e, f]
System.out.println(Arrays.equals(a, 2, 6, b, 0, 4)); // true

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [a, b]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [a, b]
System.out.println(Arrays.equals(a, 0, 2, b, 4, 6)); // true

static boolean equals (double[] a, double[] a2)

指定された2つのdouble値の配列が互いに同等である場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int[] a2)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)

指定された範囲のdoubleの2つの指定された配列が互いにequalの場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (float[] a, float[] a2)

指定された2つのfloat値の配列が互いに同等である場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int[] a2)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)

floatの指定された2つの配列が、指定された範囲にわたって、互いにequalである場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (int[] a, int[] a2)

指定された2つのint値の配列が互いに同等である場合にtrueを返します。

final int[] a = {0, 1, 2, 3, 4, 5};
final int[] a2 = {0, 1, 2, 3, 4, 5};

System.out.println(Arrays.equals(a, a2)); // true
final int[] a = {0, 1, 2, 3, 4, 5};
final int[] a2 = {2, 3, 4, 5, 0, 1};

System.out.println(Arrays.equals(a, a2)); // false
final int[] a = {1, 1, 1};
final int[] a2 = {1, 1};

System.out.println(Arrays.equals(a, a2)); // false

static boolean equals (int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

指定された範囲のintの2つの指定された配列が互いにequalである場合にtrueを返します。

final int[] a = {0, 1, 2, 3, 4, 5};
final int[] b = {2, 3, 4, 5, 0, 1};

System.out.println(Arrays.equals(a, 0, 6, b, 0, 6)); // false

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [2, 3, 4, 5]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [2, 3, 4, 5]
System.out.println(Arrays.equals(a, 2, 6, b, 0, 4)); // true

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [0, 1]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [0, 1]
System.out.println(Arrays.equals(a, 0, 2, b, 4, 6)); // true

static boolean equals (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)

指定された範囲の2つの指定されたlong配列が互いにequalの場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (long[] a, long[] a2)

指定された2つのlong値の配列が互いに同等である場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int[] a2)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)

指定された2つのshortの配列が、指定された範囲で互いにequalの場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (short[] a, short[] a2)

指定された2つのshort値の配列が互いに同等である場合にtrueを返します。

型が違うこと以外は、equals(int[] a, int[] a2)と使い方は同じです。
API使用例はそちらをご参照ください。

static boolean equals (Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)

Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。

final String[] a = {"aa", "bb", "cc", "dd", "ee", "ff"};
final String[] b = {"cc", "dd", "ee", "ff", "aa", "bb"};

System.out.println(Arrays.equals(a, 0, 6, b, 0, 6)); // false

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [cc, dd, ee, ff]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [cc, dd, ee, ff]
System.out.println(Arrays.equals(a, 2, 6, b, 0, 4)); // true

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [aa, bb]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [aa, bb]
System.out.println(Arrays.equals(a, 0, 2, b, 4, 6)); // true

static boolean equals (Object[] a, Object[] a2)

指定された2つのObjectの配列が互いに同等である場合にtrueを返します。

final String[] a = {"aa", "bb", "cc", "dd", "ee", "ff"};
final String[] a2 = {"aa", "bb", "cc", "dd", "ee", "ff"};

System.out.println(Arrays.equals(a, a2)); // true
final String[] a = {"aa", "bb", "cc", "dd", "ee", "ff"};
final String[] a2 = {"cc", "dd", "ee", "ff", "aa", "bb"};

System.out.println(Arrays.equals(a, a2)); // false
final String[] a = {"aa", "aa", "aa"};
final String[] a2 = {"aa", "aa"};

System.out.println(Arrays.equals(a, a2)); // false

static <T> boolean equals (T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)

Objectの指定された2つの配列が、指定された範囲にわたってequalである場合にtrueを返します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final Pair[] b = {
        new Pair(0, 2), new Pair(1, 0), new Pair(1, 1),
        new Pair(1, 2), new Pair(0, 0), new Pair(0, 1)};

final var cmp = new PairComparator();

System.out.println(Arrays.equals(a, 0, 6, b, 0, 6, cmp)); // false

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 2, 6))); // [(0, 2), (1, 0), (1, 1), (1, 2)]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 0, 4))); // [(0, 2), (1, 0), (1, 1), (1, 2)]
System.out.println(Arrays.equals(a, 2, 6, b, 0, 4, cmp)); // true

System.out.println(Arrays.toString(Arrays.copyOfRange(a, 0, 2))); // [(0, 0), (0, 1)]
System.out.println(Arrays.toString(Arrays.copyOfRange(b, 4, 6))); // [(0, 0), (0, 1)]
System.out.println(Arrays.equals(a, 0, 2, b, 4, 6, cmp)); // true

static <T> boolean equals (T[] a, T[] a2, Comparator<? super T> cmp)

指定された2つのObjectの配列が互いに同等である場合にtrueを返します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final Pair[] a2 = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final var cmp = new PairComparator();

System.out.println(Arrays.equals(a, a2, cmp)); // true
final Pair[] a = {
        new Pair(0, 0), new Pair(0, 1), new Pair(0, 2),
        new Pair(1, 0), new Pair(1, 1), new Pair(1, 2)};

final Pair[] a2 = {
        new Pair(0, 2), new Pair(1, 0), new Pair(1, 1),
        new Pair(1, 2), new Pair(0, 0), new Pair(0, 1)};

final var cmp = new PairComparator();

System.out.println(Arrays.equals(a, a2, cmp)); // false
final Pair[] a = {new Pair(0, 0), new Pair(0, 0), new Pair(0, 0)};
final Pair[] a2 = {new Pair(0, 0), new Pair(0, 0)};
final var cmp = new PairComparator();

System.out.println(Arrays.equals(a, a2, cmp)); // false

static void fill (boolean[] a, boolean val)

指定されたboolean値の配列の各要素に、指定されたboolean値を代入します。

final var a = new boolean[5];
System.out.println(Arrays.toString(a)); // [false, false, false, false, false]

Arrays.fill(a, true);
System.out.println(Arrays.toString(a)); // [true, true, true, true, true]

static void fill (boolean[] a, int fromIndex, int toIndex, boolean val)

boolean値で指定された配列の中で、指定された範囲にある各要素に、指定されたboolean値を割り当てます。

final var a1 = new boolean[4];
final var a2 = new boolean[4];
final var a3 = new boolean[4];
final var a4 = new boolean[4];
System.out.println(Arrays.toString(a1)); // [false, false, false, false]

Arrays.fill(a1, 0, 4, true);
Arrays.fill(a2, 0, 3, true);
Arrays.fill(a3, 0, 2, true);
Arrays.fill(a4, 0, 1, true);

System.out.println(Arrays.toString(a1)); // [true, true, true, true]
System.out.println(Arrays.toString(a2)); // [true, true, true, false]
System.out.println(Arrays.toString(a3)); // [true, true, false, false]
System.out.println(Arrays.toString(a4)); // [true, false, false, false]
final var a1 = new boolean[4];
final var a2 = new boolean[4];
final var a3 = new boolean[4];
final var a4 = new boolean[4];
System.out.println(Arrays.toString(a1)); // [false, false, false, false]

Arrays.fill(a1, 0, 4, true);
Arrays.fill(a2, 1, 4, true);
Arrays.fill(a3, 2, 4, true);
Arrays.fill(a4, 3, 4, true);

System.out.println(Arrays.toString(a1)); // [true, true, true, true]
System.out.println(Arrays.toString(a2)); // [false, true, true, true]
System.out.println(Arrays.toString(a3)); // [false, false, true, true]
System.out.println(Arrays.toString(a4)); // [false, false, false, true]

static void fill (byte[] a, byte val)

指定されたbyte値の配列の各要素に、指定されたbyte値を代入します。

型が違うこと以外は、fill(int[] a, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (byte[] a, int fromIndex, int toIndex, byte val)

byte値で指定された配列の中で、指定された範囲にある各要素に、指定されたbyte値を割り当てます。

型が違うこと以外は、fill(int[] a, int fromIndex, int toIndex, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (char[] a, char val)

指定されたchar値の配列の各要素に、指定されたchar値を代入します。

final var a = new char[5];
System.out.println(Arrays.toString(a)); // [ ,  ,  ,  ,  ]

Arrays.fill(a, 'a');
System.out.println(Arrays.toString(a)); // [a, a, a, a, a]

static void fill (char[] a, int fromIndex, int toIndex, char val)

char値で指定された配列の中で、指定された範囲にある各要素に、指定されたchar値を割り当てます。

final var a1 = new char[4];
final var a2 = new char[4];
final var a3 = new char[4];
final var a4 = new char[4];
System.out.println(Arrays.toString(a1)); // [ ,  ,  ,  ]

Arrays.fill(a1, 0, 4, 'a');
Arrays.fill(a2, 0, 3, 'a');
Arrays.fill(a3, 0, 2, 'a');
Arrays.fill(a4, 0, 1, 'a');

System.out.println(Arrays.toString(a1)); // [a, a, a, a]
System.out.println(Arrays.toString(a2)); // [a, a, a,  ]
System.out.println(Arrays.toString(a3)); // [a, a,  ,  ]
System.out.println(Arrays.toString(a4)); // [a,  ,  ,  ]
final var a1 = new char[4];
final var a2 = new char[4];
final var a3 = new char[4];
final var a4 = new char[4];
System.out.println(Arrays.toString(a1)); // [ ,  ,  ,  ]

Arrays.fill(a1, 0, 4, 'a');
Arrays.fill(a2, 1, 4, 'a');
Arrays.fill(a3, 2, 4, 'a');
Arrays.fill(a4, 3, 4, 'a');

System.out.println(Arrays.toString(a1)); // [a, a, a, a]
System.out.println(Arrays.toString(a2)); // [ , a, a, a]
System.out.println(Arrays.toString(a3)); // [ ,  , a, a]
System.out.println(Arrays.toString(a4)); // [ ,  ,  , a]

static void fill (double[] a, double val)

指定されたdouble値の配列の各要素に、指定されたdouble値を代入します。

型が違うこと以外は、fill(int[] a, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (double[] a, int fromIndex, int toIndex, double val)

double値で指定された配列の中で、指定された範囲にある各要素に、指定されたdouble値を割り当てます。

型が違うこと以外は、fill(int[] a, int fromIndex, int toIndex, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (float[] a, float val)

指定されたfloat値の配列の各要素に、指定されたfloat値を代入します。

型が違うこと以外は、fill(int[] a, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (float[] a, int fromIndex, int toIndex, float val)

float値で指定された配列の中で、指定された範囲にある各要素に、指定されたfloat値を割り当てます。

型が違うこと以外は、fill(int[] a, int fromIndex, int toIndex, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (int[] a, int val)

指定されたint値の配列の各要素に、指定されたint値を代入します。

final var a = new int[5];
System.out.println(Arrays.toString(a)); // [0, 0, 0, 0, 0]

Arrays.fill(a, 9);
System.out.println(Arrays.toString(a)); // [9, 9, 9, 9, 9]

static void fill (int[] a, int fromIndex, int toIndex, int val)

int値で指定された配列の中で、指定された範囲にある各要素に、指定されたint値を割り当てます。

final var a1 = new int[4];
final var a2 = new int[4];
final var a3 = new int[4];
final var a4 = new int[4];
System.out.println(Arrays.toString(a1)); // [0, 0, 0, 0]

Arrays.fill(a1, 0, 4, 9);
Arrays.fill(a2, 0, 3, 9);
Arrays.fill(a3, 0, 2, 9);
Arrays.fill(a4, 0, 1, 9);

System.out.println(Arrays.toString(a1)); // [9, 9, 9, 9]
System.out.println(Arrays.toString(a2)); // [9, 9, 9, 0]
System.out.println(Arrays.toString(a3)); // [9, 9, 0, 0]
System.out.println(Arrays.toString(a4)); // [9, 0, 0, 0]
final var a1 = new int[4];
final var a2 = new int[4];
final var a3 = new int[4];
final var a4 = new int[4];
System.out.println(Arrays.toString(a1)); // [0, 0, 0, 0]

Arrays.fill(a1, 0, 4, 9);
Arrays.fill(a2, 1, 4, 9);
Arrays.fill(a3, 2, 4, 9);
Arrays.fill(a4, 3, 4, 9);

System.out.println(Arrays.toString(a1)); // [9, 9, 9, 9]
System.out.println(Arrays.toString(a2)); // [0, 9, 9, 9]
System.out.println(Arrays.toString(a3)); // [0, 0, 9, 9]
System.out.println(Arrays.toString(a4)); // [0, 0, 0, 9]

static void fill (long[] a, int fromIndex, int toIndex, long val)

long値で指定された配列の中で、指定された範囲にある各要素に、指定されたlong値を割り当てます。

型が違うこと以外は、fill(int[] a, int fromIndex, int toIndex, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (long[] a, long val)

指定されたlong値の配列の各要素に、指定されたlong値を代入します。

型が違うこと以外は、fill(int[] a, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (short[] a, int fromIndex, int toIndex, short val)

short値で指定された配列の中で、指定された範囲にある各要素に、指定されたshort値を割り当てます。

型が違うこと以外は、fill(int[] a, int fromIndex, int toIndex, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (short[] a, short val)

指定されたshort値の配列の各要素に、指定されたshort値を代入します。

型が違うこと以外は、fill(int[] a, int val)と使い方は同じです。
API使用例はそちらをご参照ください。

static void fill (Object[] a, int fromIndex, int toIndex, Object val)

指定されたObjectの配列で、指定された範囲にある各要素に、指定されたObject参照を代入します。

final var a1 = new String[4];
final var a2 = new String[4];
final var a3 = new String[4];
final var a4 = new String[4];
System.out.println(Arrays.toString(a1)); // [null, null, null, null]

Arrays.fill(a1, 0, 4, "a");
Arrays.fill(a2, 0, 3, "a");
Arrays.fill(a3, 0, 2, "a");
Arrays.fill(a4, 0, 1, "a");

System.out.println(Arrays.toString(a1)); // [a, a, a, a]
System.out.println(Arrays.toString(a2)); // [a, a, a, null]
System.out.println(Arrays.toString(a3)); // [a, a, null, null]
System.out.println(Arrays.toString(a4)); // [a, null, null, null]
final var a1 = new String[4];
final var a2 = new String[4];
final var a3 = new String[4];
final var a4 = new String[4];
System.out.println(Arrays.toString(a1)); // [null, null, null, null]

Arrays.fill(a1, 0, 4, "a");
Arrays.fill(a2, 1, 4, "a");
Arrays.fill(a3, 2, 4, "a");
Arrays.fill(a4, 3, 4, "a");

System.out.println(Arrays.toString(a1)); // [a, a, a, a]
System.out.println(Arrays.toString(a2)); // [null, a, a, a]
System.out.println(Arrays.toString(a3)); // [null, null, a, a]
System.out.println(Arrays.toString(a4)); // [null, null, null, a]

static void fill (Object[] a, Object val)

指定されたObjectの配列の各要素に、指定されたObject参照を代入します。

final var a = new String[5];
System.out.println(Arrays.toString(a)); // [null, null, null, null, null]

Arrays.fill(a, "a");
System.out.println(Arrays.toString(a)); // [a, a, a, a, a]

static int hashCode (boolean[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

final boolean[] a1 = {true, false, true};
final boolean[] a2 = {true, false, true};

System.out.println(a1 != a2); // true

System.out.println(Arrays.hashCode(a1)); // 1252360
System.out.println(Arrays.hashCode(a2)); // 1252360

System.out.println(a1.hashCode()); // 964039755
System.out.println(a2.hashCode()); // 617590710

static int hashCode (byte[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

型が違うこと以外は、hashCode(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static int hashCode (char[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

final char[] a1 = {'a', 'b', 'c'};
final char[] a2 = {'a', 'b', 'c'};

System.out.println(a1 != a2); // true

System.out.println(Arrays.hashCode(a1)); // 126145
System.out.println(Arrays.hashCode(a2)); // 126145

System.out.println(a1.hashCode()); // 10241554
System.out.println(a2.hashCode()); // 741227068

static int hashCode (double[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

型が違うこと以外は、hashCode(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static int hashCode (float[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

型が違うこと以外は、hashCode(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static int hashCode (int[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

final char[] a1 = {1, 2, 3};
final char[] a2 = {1, 2, 3};

System.out.println(a1 != a2); // true

System.out.println(Arrays.hashCode(a1)); // 30817
System.out.println(Arrays.hashCode(a2)); // 30817

System.out.println(a1.hashCode()); // 636725182
System.out.println(a2.hashCode()); // 2081951401

static int hashCode (long[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

型が違うこと以外は、hashCode(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static int hashCode (short[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

型が違うこと以外は、hashCode(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static int hashCode (Object[] a)

指定された配列の内容に基づくハッシュ・コードを返します。

final String[] a1 = {"aa", "bb", "cc"};
final String[] a2 = {"aa", "bb", "cc"};

System.out.println(a1 != a2); // true

System.out.println(Arrays.hashCode(a1)); // 3113119
System.out.println(Arrays.hashCode(a2)); // 3113119

System.out.println(a1.hashCode()); // 508984302
System.out.println(a2.hashCode()); // 1140084162

static int mismatch (boolean[] a, boolean[] b)

2つのboolean配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

final boolean[] a = {true, true, true};

final boolean[] b1 = {false, false, false};
final boolean[] b2 = {true, false, false};
final boolean[] b3 = {true, true, false};
final boolean[] b4 = {true, true, true};

System.out.println(Arrays.mismatch(a, b1)); // 0
System.out.println(Arrays.mismatch(a, b2)); // 1
System.out.println(Arrays.mismatch(a, b3)); // 2
System.out.println(Arrays.mismatch(a, b4)); // -1

static int mismatch (boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)

2つのboolean配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

final boolean[] a = {true, true, true, false, false, false};
final boolean[] b = {true, true, true, true, true, true};

System.out.println(Arrays.mismatch(a, 0, 6, b, 0, 6)); // 3

System.out.println(Arrays.mismatch(a, 0, 5, b, 0, 5)); // 3
System.out.println(Arrays.mismatch(a, 0, 4, b, 0, 4)); // 3
System.out.println(Arrays.mismatch(a, 0, 3, b, 0, 3)); // -1

System.out.println(Arrays.mismatch(a, 1, 6, b, 1, 6)); // 2
System.out.println(Arrays.mismatch(a, 2, 6, b, 2, 6)); // 1
System.out.println(Arrays.mismatch(a, 3, 6, b, 3, 6)); // 0

static int mismatch (byte[] a, byte[] b)

2つのbyte配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)

2つのbyte配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (char[] a, char[] b)

2つのchar配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

final char[] a = {'a', 'b', 'c'};

final char[] b1 = {'z', 'b', 'c'};
final char[] b2 = {'a', 'z', 'c'};
final char[] b3 = {'a', 'b', 'z'};
final char[] b4 = {'a', 'b', 'c'};

System.out.println(Arrays.mismatch(a, b1)); // 0
System.out.println(Arrays.mismatch(a, b2)); // 1
System.out.println(Arrays.mismatch(a, b3)); // 2
System.out.println(Arrays.mismatch(a, b4)); // -1

static int mismatch (char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)

2つのchar配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

final char[] a = {'a', 'b', 'c', 'd', 'e', 'f'};
final char[] b = {'a', 'b', 'c', 'x', 'y', 'z'};

System.out.println(Arrays.mismatch(a, 0, 6, b, 0, 6)); // 3

System.out.println(Arrays.mismatch(a, 0, 5, b, 0, 5)); // 3
System.out.println(Arrays.mismatch(a, 0, 4, b, 0, 4)); // 3
System.out.println(Arrays.mismatch(a, 0, 3, b, 0, 3)); // -1

System.out.println(Arrays.mismatch(a, 1, 6, b, 1, 6)); // 2
System.out.println(Arrays.mismatch(a, 2, 6, b, 2, 6)); // 1
System.out.println(Arrays.mismatch(a, 3, 6, b, 3, 6)); // 0

static int mismatch (double[] a, double[] b)

2つのdouble配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)

2つのdouble配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (float[] a, float[] b)

2つのfloat配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)

2つのfloat配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (int[] a, int[] b)

2つのint配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

final int[] a = {0, 1, 2};

final int[] b1 = {9, 1, 2};
final int[] b2 = {0, 9, 2};
final int[] b3 = {0, 1, 9};
final int[] b4 = {0, 1, 2};

System.out.println(Arrays.mismatch(a, b1)); // 0
System.out.println(Arrays.mismatch(a, b2)); // 1
System.out.println(Arrays.mismatch(a, b3)); // 2
System.out.println(Arrays.mismatch(a, b4)); // -1

static int mismatch (int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

2つのint配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

final int[] a = {0, 1, 2, 3, 4, 5};
final int[] b = {0, 1, 2, 30, 40, 50};

System.out.println(Arrays.mismatch(a, 0, 6, b, 0, 6)); // 3

System.out.println(Arrays.mismatch(a, 0, 5, b, 0, 5)); // 3
System.out.println(Arrays.mismatch(a, 0, 4, b, 0, 4)); // 3
System.out.println(Arrays.mismatch(a, 0, 3, b, 0, 3)); // -1

System.out.println(Arrays.mismatch(a, 1, 6, b, 1, 6)); // 2
System.out.println(Arrays.mismatch(a, 2, 6, b, 2, 6)); // 1
System.out.println(Arrays.mismatch(a, 3, 6, b, 3, 6)); // 0

static int mismatch (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)

2つのlong配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (long[] a, long[] b)

2つのlong配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)

2つのshort配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (short[] a, short[] b)

2つのshort配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

型が違うこと以外は、mismatch(int[] a, int[] b)と使い方は同じです。
API使用例はそちらをご参照ください。

static int mismatch (Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)

2つのObject配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

final String[] a = {"a", "b", "c", "d", "e", "f"};
final String[] b = {"a", "b", "c", "x", "y", "z"};

System.out.println(Arrays.mismatch(a, 0, 6, b, 0, 6)); // 3

System.out.println(Arrays.mismatch(a, 0, 5, b, 0, 5)); // 3
System.out.println(Arrays.mismatch(a, 0, 4, b, 0, 4)); // 3
System.out.println(Arrays.mismatch(a, 0, 3, b, 0, 3)); // -1

System.out.println(Arrays.mismatch(a, 1, 6, b, 1, 6)); // 2
System.out.println(Arrays.mismatch(a, 2, 6, b, 2, 6)); // 1
System.out.println(Arrays.mismatch(a, 3, 6, b, 3, 6)); // 0

static int mismatch (Object[] a, Object[] b)

2つのObject配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

final String[] a = {"a", "b", "c"};

final String[] b1 = {"z", "b", "c"};
final String[] b2 = {"a", "z", "c"};
final String[] b3 = {"a", "b", "z"};
final String[] b4 = {"a", "b", "c"};

System.out.println(Arrays.mismatch(a, b1)); // 0
System.out.println(Arrays.mismatch(a, b2)); // 1
System.out.println(Arrays.mismatch(a, b3)); // 2
System.out.println(Arrays.mismatch(a, b4)); // -1

static <T> int mismatch (T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)

2つのObject配列間の最初の不一致の相対インデックスを指定された範囲で検索して返します。一致しない場合は -1を返します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(0, 1), new Pair(0, 2), new Pair(0, 3),
        new Pair(0, 4), new Pair(0, 5), new Pair(0, 6)};

final Pair[] b = {
        new Pair(0, 1), new Pair(0, 2), new Pair(0, 3),
        new Pair(1, 1), new Pair(1, 2), new Pair(1, 3)};

final var cmp = new PairComparator();

System.out.println(Arrays.mismatch(a, 0, 6, b, 0, 6, cmp)); // 3

System.out.println(Arrays.mismatch(a, 0, 5, b, 0, 5, cmp)); // 3
System.out.println(Arrays.mismatch(a, 0, 4, b, 0, 4, cmp)); // 3
System.out.println(Arrays.mismatch(a, 0, 3, b, 0, 3, cmp)); // -1

System.out.println(Arrays.mismatch(a, 1, 6, b, 1, 6, cmp)); // 2
System.out.println(Arrays.mismatch(a, 2, 6, b, 2, 6, cmp)); // 1
System.out.println(Arrays.mismatch(a, 3, 6, b, 3, 6, cmp)); // 0

static <T> int mismatch (T[] a, T[] b, Comparator<? super T> cmp)

2つのObject配列間の最初の不一致のインデックスを見つけて返します。一致しない場合は -1を返します。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {new Pair(0, 1), new Pair(0, 2), new Pair(0, 3)};

final Pair[] b1 = {new Pair(9, 9), new Pair(0, 2), new Pair(0, 3)};
final Pair[] b2 = {new Pair(0, 1), new Pair(9, 9), new Pair(0, 3)};
final Pair[] b3 = {new Pair(0, 1), new Pair(0, 2), new Pair(9, 9)};
final Pair[] b4 = {new Pair(0, 1), new Pair(0, 2), new Pair(0, 3)};

final var cmp = new PairComparator();

System.out.println(Arrays.mismatch(a, b1, cmp)); // 0
System.out.println(Arrays.mismatch(a, b2, cmp)); // 1
System.out.println(Arrays.mismatch(a, b3, cmp)); // 2
System.out.println(Arrays.mismatch(a, b4, cmp)); // -1

static void parallelPrefix (double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)

配列の指定された部分範囲に対してparallelPrefix(double[], DoubleBinaryOperator)を実行します。

型が違うこと以外は、parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelPrefix (double[] array, DoubleBinaryOperator op)

指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。

型が違うこと以外は、parallelPrefix(int[] array, IntBinaryOperator op)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelPrefix (int[] array, int fromIndex, int toIndex, IntBinaryOperator op)

配列の指定された部分範囲に対してparallelPrefix(int[], IntBinaryOperator)を実行します。

final int[] array = {1, 2, 3, 4, 5, 6};

System.out.println("array : " + Arrays.toString(Arrays.copyOfRange(array, 2, 5)));

Arrays.parallelPrefix(array, 2, 5, (left, right) -> {
    System.out.println("left = %d : right = %d".formatted(left, right));
    return left + right;
});

System.out.println("array : " + Arrays.toString(array));

// 結果
// ↓
//array : [3, 4, 5]
//left = 3 : right = 4
//left = 7 : right = 5
//array : [1, 2, 3, 7, 12, 6]

static void parallelPrefix (int[] array, IntBinaryOperator op)

指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。

final int[] array = {1, 2, 3, 4};

Arrays.parallelPrefix(array, (left, right) -> {
    System.out.println("left = %d : right = %d".formatted(left, right));
    return left + right;
});

System.out.println("array : " + Arrays.toString(array));

// 結果
// ↓
//left = 1 : right = 2
//left = 3 : right = 3
//left = 6 : right = 4
//array : [1, 3, 6, 10]

static void parallelPrefix (long[] array, int fromIndex, int toIndex, LongBinaryOperator op)

配列の指定された部分範囲に対してparallelPrefix(long[], LongBinaryOperator)を実行します。

型が違うこと以外は、parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelPrefix (long[] array, LongBinaryOperator op)

指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。

型が違うこと以外は、parallelPrefix(int[] array, IntBinaryOperator op)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> void parallelPrefix (T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)

配列の指定された部分範囲に対してparallelPrefix(Object[], BinaryOperator)を実行します。

final String[] array = {"a", "b", "c", "d", "e", "f"};

System.out.println("array : " + Arrays.toString(Arrays.copyOfRange(array, 2, 5)));

Arrays.parallelPrefix(array, 2, 5, (left, right) -> {
    System.out.println("left = %s : right = %s".formatted(left, right));
    return left + right;
});

System.out.println("array : " + Arrays.toString(array));

// 結果
// ↓
//array : [c, d, e]
//left = c : right = d
//left = cd : right = e
//array : [a, b, c, cd, cde, f]

static <T> void parallelPrefix (T[] array, BinaryOperator<T> op)

指定された関数を使用して、指定された配列の各要素をその場で並列に累積します。

final String[] array = {"a", "b", "c", "d"};

Arrays.parallelPrefix(array, (left, right) -> {
    System.out.println("left = %s : right = %s".formatted(left, right));
    return left + right;
});

System.out.println("array : " + Arrays.toString(array));

// 結果
// ↓
//left = a : right = b
//left = ab : right = c
//left = abc : right = d
//array : [a, ab, abc, abcd]

static void parallelSetAll (double[] array, IntToDoubleFunction generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。

型が違うこと以外は、parallelSetAll(int[] array, IntUnaryOperator generator)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSetAll (int[] array, IntUnaryOperator generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。

final var array = new int[5];

System.out.println("array : " + Arrays.toString(array));

Arrays.parallelSetAll(array, index -> {
    final var id = Thread.currentThread().getId();
    System.out.println("thread id = %d : index = %d".formatted(id, index));
    return index * 2;
});

System.out.println("arrays : " + Arrays.toString(array));

// 結果
// ↓
//array : [0, 0, 0, 0, 0]
//thread id = 16 : index = 2
//thread id = 21 : index = 0
//thread id = 23 : index = 3
//thread id = 20 : index = 4
//thread id = 19 : index = 1
//arrays : [0, 2, 4, 6, 8]

static void parallelSetAll (long[] array, IntToLongFunction generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。

型が違うこと以外は、parallelSetAll(int[] array, IntUnaryOperator generator)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> void parallelSetAll (T[] array, IntFunction<? extends T> generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を並列に設定します。

final var array = new String[5];

System.out.println("array : " + Arrays.toString(array));

Arrays.parallelSetAll(array, index -> {
    final var id = Thread.currentThread().getId();
    System.out.println("thread id = %d : index = %d".formatted(id, index));
    return "a".repeat(index + 1);
});

System.out.println(Arrays.toString(array));

// 結果
// ↓
//array : [null, null, null, null, null]
//thread id = 16 : index = 2
//thread id = 20 : index = 4
//thread id = 19 : index = 1
//thread id = 21 : index = 3
//thread id = 22 : index = 0
//[a, aa, aaa, aaaa, aaaaa]

static void parallelSort (byte[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (byte[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (char[] a)

指定された配列を数値の昇順でソートします。

final char[] a = {'d', 'c', 'b', 'a'};

Arrays.parallelSort(a);

System.out.println(Arrays.toString(a)); // [a, b, c, d]

static void parallelSort (char[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

final char[] a = {'d', 'c', 'b', 'a'};

{
    final char[] a1 = a.clone();
    final char[] a2 = a.clone();
    final char[] a3 = a.clone();
    final char[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 0, 3);
    Arrays.parallelSort(a3, 0, 2);
    Arrays.parallelSort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [b, c, d, a]
    System.out.println(Arrays.toString(a3)); // [c, d, b, a]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

{
    final char[] a1 = a.clone();
    final char[] a2 = a.clone();
    final char[] a3 = a.clone();
    final char[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 1, 4);
    Arrays.parallelSort(a3, 2, 4);
    Arrays.parallelSort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [d, a, b, c]
    System.out.println(Arrays.toString(a3)); // [d, c, a, b]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

static void parallelSort (double[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (double[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (float[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (float[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (int[] a)

指定された配列を数値の昇順でソートします。

final int[] a = {4, 3, 2, 1};

Arrays.parallelSort(a);

System.out.println(Arrays.toString(a)); // [1, 2, 3, 4]

static void parallelSort (int[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

final int[] a = {4, 3, 2, 1};

{
    final int[] a1 = a.clone();
    final int[] a2 = a.clone();
    final int[] a3 = a.clone();
    final int[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 0, 3);
    Arrays.parallelSort(a3, 0, 2);
    Arrays.parallelSort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [1, 2, 3, 4]
    System.out.println(Arrays.toString(a2)); // [2, 3, 4, 1]
    System.out.println(Arrays.toString(a3)); // [3, 4, 2, 1]
    System.out.println(Arrays.toString(a4)); // [4, 3, 2, 1]
}

{
    final int[] a1 = a.clone();
    final int[] a2 = a.clone();
    final int[] a3 = a.clone();
    final int[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 1, 4);
    Arrays.parallelSort(a3, 2, 4);
    Arrays.parallelSort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [1, 2, 3, 4]
    System.out.println(Arrays.toString(a2)); // [4, 1, 2, 3]
    System.out.println(Arrays.toString(a3)); // [4, 3, 1, 2]
    System.out.println(Arrays.toString(a4)); // [4, 3, 2, 1]
}

static void parallelSort (long[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (long[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (short[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void parallelSort (short[] a, int fromIndex, int toIndex)

配列の指定された範囲を数値の昇順でソートします。

型が違うこと以外は、parallelSort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T extends Comparable<? super T>> void parallelSort (T[] a)

指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。

// StringクラスはComparableを実装しています。
final String[] a = {"d", "c", "b", "a"};

Arrays.parallelSort(a);

System.out.println(Arrays.toString(a)); // [a, b, c, d]

static <T extends Comparable<? super T>> void parallelSort (T[] a, int fromIndex, int toIndex)

指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。

// StringクラスはComparableを実装しています。
final String[] a = {"d", "c", "b", "a"};

{
    final String[] a1 = a.clone();
    final String[] a2 = a.clone();
    final String[] a3 = a.clone();
    final String[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 0, 3);
    Arrays.parallelSort(a3, 0, 2);
    Arrays.parallelSort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [b, c, d, a]
    System.out.println(Arrays.toString(a3)); // [c, d, b, a]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

{
    final String[] a1 = a.clone();
    final String[] a2 = a.clone();
    final String[] a3 = a.clone();
    final String[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4);
    Arrays.parallelSort(a2, 1, 4);
    Arrays.parallelSort(a3, 2, 4);
    Arrays.parallelSort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [d, a, b, c]
    System.out.println(Arrays.toString(a3)); // [d, c, a, b]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

static <T> void parallelSort (T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)

指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 2), new Pair(2, 1),
        new Pair(1, 2), new Pair(1, 1)};

final var cmp = new PairComparator();

{
    final Pair[] a1 = a.clone();
    final Pair[] a2 = a.clone();
    final Pair[] a3 = a.clone();
    final Pair[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4, cmp);
    Arrays.parallelSort(a2, 0, 3, cmp);
    Arrays.parallelSort(a3, 0, 2, cmp);
    Arrays.parallelSort(a4, 0, 1, cmp);

    System.out.println(Arrays.toString(a1)); // [(1, 1), (1, 2), (2, 1), (2, 2)]
    System.out.println(Arrays.toString(a2)); // [(1, 2), (2, 1), (2, 2), (1, 1)]
    System.out.println(Arrays.toString(a3)); // [(2, 1), (2, 2), (1, 2), (1, 1)]
    System.out.println(Arrays.toString(a4)); // [(2, 2), (2, 1), (1, 2), (1, 1)]
}

{
    final Pair[] a1 = a.clone();
    final Pair[] a2 = a.clone();
    final Pair[] a3 = a.clone();
    final Pair[] a4 = a.clone();

    Arrays.parallelSort(a1, 0, 4, cmp);
    Arrays.parallelSort(a2, 1, 4, cmp);
    Arrays.parallelSort(a3, 2, 4, cmp);
    Arrays.parallelSort(a4, 3, 4, cmp);

    System.out.println(Arrays.toString(a1)); // [(1, 1), (1, 2), (2, 1), (2, 2)]
    System.out.println(Arrays.toString(a2)); // [(2, 2), (1, 1), (1, 2), (2, 1)]
    System.out.println(Arrays.toString(a3)); // [(2, 2), (2, 1), (1, 1), (1, 2)]
    System.out.println(Arrays.toString(a4)); // [(2, 2), (2, 1), (1, 2), (1, 1)]
}

static <T> void parallelSort (T[] a, Comparator<? super T> cmp)

指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 2), new Pair(2, 1),
        new Pair(1, 2), new Pair(1, 1)};

final var cmp = new PairComparator();

Arrays.parallelSort(a, cmp);

System.out.println(Arrays.toString(a)); // [(1, 1), (1, 2), (2, 1), (2, 2)]

static void setAll (double[] array, IntToDoubleFunction generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。

型が違うこと以外は、setAll(int[] array, IntUnaryOperator generator)と使い方は同じです。
API使用例はそちらをご参照ください。

static void setAll (int[] array, IntUnaryOperator generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。

final var array = new int[5];

System.out.println("array : " + Arrays.toString(array));

Arrays.setAll(array, index -> {
    System.out.println("index = %d".formatted(index));
    return index * 2;
});

System.out.println("arrays : " + Arrays.toString(array));

// 結果
// ↓
//array : [0, 0, 0, 0, 0]
//index = 0
//index = 1
//index = 2
//index = 3
//index = 4
//arrays : [0, 2, 4, 6, 8]

static void setAll (long[] array, IntToLongFunction generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。

型が違うこと以外は、setAll(int[] array, IntUnaryOperator generator)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> void setAll (T[] array, IntFunction<? extends T> generator)

指定されたジェネレータ関数を使用して指定された配列の各要素を計算することで、すべての要素を設定します。

final var array = new String[5];

System.out.println("array : " + Arrays.toString(array));

Arrays.setAll(array, index -> {
    System.out.println("index = %d".formatted(index));
    return "a".repeat(index + 1);
});

System.out.println(Arrays.toString(array));

// 結果
// ↓
//array : [null, null, null, null, null]
//index = 0
//index = 1
//index = 2
//index = 3
//index = 4
//[a, aa, aaa, aaaa, aaaaa]

static void sort (byte[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、sort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (byte[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

型が違うこと以外は、sort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (char[] a)

指定された配列を数値の昇順でソートします。

final char[] a = {'d', 'c', 'b', 'a'};

Arrays.sort(a);

System.out.println(Arrays.toString(a)); // [a, b, c, d]

static void sort (char[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

final char[] a = {'d', 'c', 'b', 'a'};

{
    final char[] a1 = a.clone();
    final char[] a2 = a.clone();
    final char[] a3 = a.clone();
    final char[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 0, 3);
    Arrays.sort(a3, 0, 2);
    Arrays.sort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [b, c, d, a]
    System.out.println(Arrays.toString(a3)); // [c, d, b, a]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

{
    final char[] a1 = a.clone();
    final char[] a2 = a.clone();
    final char[] a3 = a.clone();
    final char[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 1, 4);
    Arrays.sort(a3, 2, 4);
    Arrays.sort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [d, a, b, c]
    System.out.println(Arrays.toString(a3)); // [d, c, a, b]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

static void sort (double[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、sort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (double[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

型が違うこと以外は、sort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (float[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、sort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (float[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

型が違うこと以外は、sort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (int[] a)

指定された配列を数値の昇順でソートします。

final int[] a = {4, 3, 2, 1};

Arrays.sort(a);

System.out.println(Arrays.toString(a)); // [1, 2, 3, 4]

static void sort (int[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

final int[] a = {4, 3, 2, 1};

{
    final int[] a1 = a.clone();
    final int[] a2 = a.clone();
    final int[] a3 = a.clone();
    final int[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 0, 3);
    Arrays.sort(a3, 0, 2);
    Arrays.sort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [1, 2, 3, 4]
    System.out.println(Arrays.toString(a2)); // [2, 3, 4, 1]
    System.out.println(Arrays.toString(a3)); // [3, 4, 2, 1]
    System.out.println(Arrays.toString(a4)); // [4, 3, 2, 1]
}

{
    final int[] a1 = a.clone();
    final int[] a2 = a.clone();
    final int[] a3 = a.clone();
    final int[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 1, 4);
    Arrays.sort(a3, 2, 4);
    Arrays.sort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [1, 2, 3, 4]
    System.out.println(Arrays.toString(a2)); // [4, 1, 2, 3]
    System.out.println(Arrays.toString(a3)); // [4, 3, 1, 2]
    System.out.println(Arrays.toString(a4)); // [4, 3, 2, 1]
}

static void sort (long[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、sort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (long[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

型が違うこと以外は、sort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (short[] a)

指定された配列を数値の昇順でソートします。

型が違うこと以外は、sort(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (short[] a, int fromIndex, int toIndex)

指定された範囲の配列を昇順にソートします。

型が違うこと以外は、sort(int[] a, int fromIndex, int toIndex)と使い方は同じです。
API使用例はそちらをご参照ください。

static void sort (Object[] a)

指定されたオブジェクト配列を、その要素の自然順序付けに従って昇順にソートします。

// StringクラスはComparableを実装しています。
final String[] a = {"d", "c", "b", "a"};

Arrays.sort(a);

System.out.println(Arrays.toString(a)); // [a, b, c, d]

static void sort (Object[] a, int fromIndex, int toIndex)

指定されたオブジェクト配列の指定された範囲を、その要素の自然順序付けに従って昇順にソートします。

// StringクラスはComparableを実装しています。
final String[] a = {"d", "c", "b", "a"};

{
    final String[] a1 = a.clone();
    final String[] a2 = a.clone();
    final String[] a3 = a.clone();
    final String[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 0, 3);
    Arrays.sort(a3, 0, 2);
    Arrays.sort(a4, 0, 1);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [b, c, d, a]
    System.out.println(Arrays.toString(a3)); // [c, d, b, a]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

{
    final String[] a1 = a.clone();
    final String[] a2 = a.clone();
    final String[] a3 = a.clone();
    final String[] a4 = a.clone();

    Arrays.sort(a1, 0, 4);
    Arrays.sort(a2, 1, 4);
    Arrays.sort(a3, 2, 4);
    Arrays.sort(a4, 3, 4);

    System.out.println(Arrays.toString(a1)); // [a, b, c, d]
    System.out.println(Arrays.toString(a2)); // [d, a, b, c]
    System.out.println(Arrays.toString(a3)); // [d, c, a, b]
    System.out.println(Arrays.toString(a4)); // [d, c, b, a]
}

static <T> void sort (T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

指定されたコンパレータの順番に従って、指定されたオブジェクトの配列の指定範囲を昇順でソートします。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 2), new Pair(2, 1),
        new Pair(1, 2), new Pair(1, 1)};

final var c = new PairComparator();

{
    final Pair[] a1 = a.clone();
    final Pair[] a2 = a.clone();
    final Pair[] a3 = a.clone();
    final Pair[] a4 = a.clone();

    Arrays.sort(a1, 0, 4, c);
    Arrays.sort(a2, 0, 3, c);
    Arrays.sort(a3, 0, 2, c);
    Arrays.sort(a4, 0, 1, c);

    System.out.println(Arrays.toString(a1)); // [(1, 1), (1, 2), (2, 1), (2, 2)]
    System.out.println(Arrays.toString(a2)); // [(1, 2), (2, 1), (2, 2), (1, 1)]
    System.out.println(Arrays.toString(a3)); // [(2, 1), (2, 2), (1, 2), (1, 1)]
    System.out.println(Arrays.toString(a4)); // [(2, 2), (2, 1), (1, 2), (1, 1)]
}

{
    final Pair[] a1 = a.clone();
    final Pair[] a2 = a.clone();
    final Pair[] a3 = a.clone();
    final Pair[] a4 = a.clone();

    Arrays.sort(a1, 0, 4, c);
    Arrays.sort(a2, 1, 4, c);
    Arrays.sort(a3, 2, 4, c);
    Arrays.sort(a4, 3, 4, c);

    System.out.println(Arrays.toString(a1)); // [(1, 1), (1, 2), (2, 1), (2, 2)]
    System.out.println(Arrays.toString(a2)); // [(2, 2), (1, 1), (1, 2), (2, 1)]
    System.out.println(Arrays.toString(a3)); // [(2, 2), (2, 1), (1, 1), (1, 2)]
    System.out.println(Arrays.toString(a4)); // [(2, 2), (2, 1), (1, 2), (1, 1)]
}

static <T> void sort (T[] a, Comparator<? super T> c)

指定されたコンパレータが示す順序に従って、指定されたオブジェクトの配列をソートします。

PairとPairComparatorについてはこちらをご参照ください。

final Pair[] a = {
        new Pair(2, 2), new Pair(2, 1),
        new Pair(1, 2), new Pair(1, 1)};

final var c = new PairComparator();

Arrays.sort(a, c);

System.out.println(Arrays.toString(a)); // [(1, 1), (1, 2), (2, 1), (2, 2)]

static Spliterator.OfDouble spliterator (double[] array)

指定された配列のすべてに適用されるSpliterator.OfDoubleを返します。

型が違うこと以外は、spliterator(int[] array)と使い方は同じです。
API使用例はそちらをご参照ください。

static Spliterator.OfDouble spliterator (double[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲に適用されるSpliterator.OfDoubleを返します。

型が違うこと以外は、spliterator(int[] array, int startInclusive, int endExclusive)と使い方は同じです。
API使用例はそちらをご参照ください。

static Spliterator.OfInt spliterator (int[] array)

指定された配列のすべてに適用されるSpliterator.OfIntを返します。

final int[] array = {1, 2, 3, 4};

final var spliterator = Arrays.spliterator(array);

spliterator.forEachRemaining((IntConsumer) value -> {
    System.out.print(value + " ");
});

// 結果
// ↓
//1 2 3 4 

static Spliterator.OfInt spliterator (int[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲に適用されるSpliterator.OfIntを返します。

final int[] array = {1, 2, 3, 4};

Arrays.spliterator(array, 0, 4)
        .forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 3)
        .forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 2)
        .forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 1)
        .forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

// 結果
// ↓
//1 2 3 4 
//1 2 3 
//1 2 
//1 
final int[] array = {1, 2, 3, 4};

Arrays.spliterator(array, 0, 4).
        forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 1, 4).
        forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 2, 4).
        forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 3, 4).
        forEachRemaining((IntConsumer) value -> System.out.print(value + " "));
System.out.println();

// 結果
// ↓
//1 2 3 4 
//2 3 4 
//3 4 
//4 

static Spliterator.OfLong spliterator (long[] array)

指定された配列のすべてに適用されるSpliterator.OfLongを返します。

型が違うこと以外は、spliterator(int[] array)と使い方は同じです。
API使用例はそちらをご参照ください。

static Spliterator.OfLong spliterator (long[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲に適用されるSpliterator.OfLongを返します。

型が違うこと以外は、spliterator(int[] array, int startInclusive, int endExclusive)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> Spliterator<T> spliterator (T[] array)

指定された配列のすべてに適用されるSpliteratorを返します。

final String[] array = {"a", "b", "c", "d"};

final var spliterator = Arrays.spliterator(array);

spliterator.forEachRemaining(value -> {
    System.out.print(value + " ");
});

// 結果
// ↓
//a b c d 

static <T> Spliterator<T> spliterator (T[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲に適用されるSpliteratorを返します。

final String[] array = {"a", "b", "c", "d"};

Arrays.spliterator(array, 0, 4).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 3).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 2).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 0, 1).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

// 結果
// ↓
//a b c d 
//a b c 
//a b 
//a 
final String[] array = {"a", "b", "c", "d"};

Arrays.spliterator(array, 0, 4).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 1, 4).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 2, 4).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

Arrays.spliterator(array, 3, 4).forEachRemaining(value -> System.out.print(value + " "));
System.out.println();

// 結果
// ↓
//a b c d 
//b c d 
//c d 
//d 

static DoubleStream stream (double[] array)

指定された配列をソースとして使用して、逐次的なDoubleStreamを返します。

型が違うこと以外は、stream(int[] array)と使い方は同じです。
API使用例はそちらをご参照ください。

static DoubleStream stream (double[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲をソースとして使用して、逐次的なDoubleStreamを返します。

型が違うこと以外は、stream(int[] array, int startInclusive, int endExclusive)と使い方は同じです。
API使用例はそちらをご参照ください。

static IntStream stream (int[] array)

指定された配列をソースとして使用して、逐次的なIntStreamを返します。

final int[] array = {1, 2, 3, 4};

final var stream = Arrays.stream(array);

final var s = stream.mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));
System.out.println(s); // 2, 4, 6, 8

static IntStream stream (int[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲をソースとして使用して、逐次的なIntStreamを返します。

final int[] array = {1, 2, 3, 4};

final var s1 = Arrays.stream(array, 0, 4)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s2 = Arrays.stream(array, 0, 3)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s3 = Arrays.stream(array, 0, 2)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s4 = Arrays.stream(array, 0, 1)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

System.out.println(s1); // 2, 4, 6, 8
System.out.println(s2); // 2, 4, 6
System.out.println(s3); // 2, 4
System.out.println(s4); // 2
final int[] array = {1, 2, 3, 4};

final var s1 = Arrays.stream(array, 0, 4)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s2 = Arrays.stream(array, 1, 4)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s3 = Arrays.stream(array, 2, 4)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

final var s4 = Arrays.stream(array, 3, 4)
        .mapToObj(value -> String.valueOf(value * 2)).collect(Collectors.joining(", "));

System.out.println(s1); // 2, 4, 6, 8
System.out.println(s2); // 4, 6, 8
System.out.println(s3); // 6, 8
System.out.println(s4); // 8

static LongStream stream (long[] array)

指定された配列をソースとして使用して、逐次的なLongStreamを返します。

型が違うこと以外は、stream(int[] array)と使い方は同じです。
API使用例はそちらをご参照ください。

static LongStream stream (long[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲をソースとして使用して、逐次的なLongStreamを返します。

型が違うこと以外は、stream(int[] array, int startInclusive, int endExclusive)と使い方は同じです。
API使用例はそちらをご参照ください。

static <T> Stream<T> stream (T[] array)

指定された配列をソースとして使用して、逐次的なStreamを返します。

final String[] array = {"a", "b", "c", "d"};

final var stream = Arrays.stream(array);

final var s = stream.map(value -> value.repeat(3)).collect(Collectors.joining(", "));
System.out.println(s); // aaa, bbb, ccc, ddd

static <T> Stream<T> stream (T[] array, int startInclusive, int endExclusive)

指定された配列の指定された範囲をソースとして使用して、逐次的なStreamを返します。

final String[] array = {"a", "b", "c", "d"};

final var s1 = Arrays.stream(array, 0, 4)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s2 = Arrays.stream(array, 0, 3)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s3 = Arrays.stream(array, 0, 2)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s4 = Arrays.stream(array, 0, 1)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

System.out.println(s1); // aaa, bbb, ccc, ddd
System.out.println(s2); // aaa, bbb, ccc
System.out.println(s3); // aaa, bbb
System.out.println(s4); // aaa
final String[] array = {"a", "b", "c", "d"};

final var s1 = Arrays.stream(array, 0, 4)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s2 = Arrays.stream(array, 1, 4)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s3 = Arrays.stream(array, 2, 4)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

final var s4 = Arrays.stream(array, 3, 4)
        .map(value -> value.repeat(3)).collect(Collectors.joining(", "));

System.out.println(s1); // aaa, bbb, ccc, ddd
System.out.println(s2); // bbb, ccc, ddd
System.out.println(s3); // ccc, ddd
System.out.println(s4); // ddd

static String toString (boolean[] a)

指定された配列の文字列表現を返します。

final boolean[] a = {true, false, true, false};
System.out.println(Arrays.toString(a)); // [true, false, true, false]

static String toString (byte[] a)

指定された配列の文字列表現を返します。

型が違うこと以外は、toString(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static String toString (char[] a)

指定された配列の文字列表現を返します。

final char[] a = {'a', 'b', 'c', 'd'};
System.out.println(Arrays.toString(a)); // [a, b, c, d]

static String toString (double[] a)

指定された配列の文字列表現を返します。

型が違うこと以外は、toString(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static String toString (float[] a)

指定された配列の文字列表現を返します。

型が違うこと以外は、toString(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static String toString (int[] a)

指定された配列の文字列表現を返します。

final int[] a = {1, 2, 3, 4};
System.out.println(Arrays.toString(a)); // [1, 2, 3, 4]

static String toString (long[] a)

指定された配列の文字列表現を返します。

型が違うこと以外は、toString(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static String toString (short[] a)

指定された配列の文字列表現を返します。

型が違うこと以外は、toString(int[] a)と使い方は同じです。
API使用例はそちらをご参照ください。

static String toString (Object[] a)

指定された配列の文字列表現を返します。

final String[] a = {"a", "b", "c", "d"};
System.out.println(Arrays.toString(a)); // [a, b, c, d]

関連記事

ページの先頭へ