Java – 演算子 – 文字列結合

2021-06-17 / tau / コメントする

文字列同士の結合

+演算子の左右のオペランドが文字列の時、演算子は文字列結合として機能する。

System.out.println("ABC" + "DEF"); // ABCDEF

1	System.out.println("ABC" + "DEF"); // ABCDEF

文字列以外との結合

数値との結合

左右のオペランドの何れか1つが文字列の時も文字列結合として機能し、他方のオペランドは文字列に変換された後に結合される。

以下は文字列と数値を+演算子で結んだ場合で、数値が文字列に変換されて結合される。左右とも数値の場合は、当然数値の加算演算子として機能する。

System.out.println("ABC" + 123); // ABC123
System.out.println(123 + "ABC"); // 123ABC
System.out.println(123 + 456);   // 579

System.out.println("ABC" + 123); // ABC123

System.out.println(123 + "ABC"); // 123ABC

System.out.println(123 + 456); // 579

char型との結合

char型の場合も文字列として結合される。左右ともchar型の場合はchar同士の値の加算(以下の例では’a’ + ‘b’ = $61 + $62 = $C3 = 195)。

System.out.println("ABC" + "d"); // ABCd
System.out.println('a' + "BCD"); // aBCD
System.out.println('a' + 'b');   // 195

System.out.println("ABC" + "d"); // ABCd

System.out.println('a' + "BCD"); // aBCD

System.out.println('a' + 'b'); // 195

一般的のオブジェクトとの結合

+演算子のオペランドの1つが文字列で他方がそうでないとき、演算子は文字列でない方のオペランドの文字列表現を結合する。

たとえば配列同士の+演算子は定義されていないが、文字列と配列を+演算子で結ぶと配列の方が文字列表現(ハッシュ)になり、もう1法の文字列と結合される。

int[] array1 = {1, 2, 3};
int[] array2 = {4, 5, 6};
// System.out.println(array1 + array2); // +演算子の未定義エラー
System.out.println(array1 + "ABC"); // [I@41a4555eABC
System.out.println("ABC" + array1); // ABC[I@41a4555e

int[] array1 = {1, 2, 3};

int[] array2 = {4, 5, 6};

// System.out.println(array1 + array2); // +演算子の未定義エラー

System.out.println(array1 + "ABC"); // [I@41a4555eABC

System.out.println("ABC" + array1); // ABC[I@41a4555e

以下の例はtoString()が実装されたクラスのオブジェクトと文字列の結合例で、Listオブジェクトが文字列化された後に結合されている。

String[] str = {"D", "E", "F"};
java.util.List<String> list = java.util.Arrays.asList(str);
System.out.println("ABC" + list); // ABC[D, E, F]
System.out.println(list + "GHI"); // [D, E, F]GHI

String[] str = {"D", "E", "F"};

java.util.List<String> list = java.util.Arrays.asList(str);

System.out.println("ABC" + list); // ABC[D, E, F]

System.out.println(list + "GHI"); // [D, E, F]GHI

Java – 演算子 – 代入演算子

2021-06-17 / tau / コメントする

数値に対する代入演算子

`a = b`	`b`の値を`a`に代入する
`a += b`	`a = a + b`と等価
`a -= b`	`a = a ― b`と等価
`a *= b`	`a = a * b`と等価
`a /= b`	`a = a / b`と等価
`a %= b`	`a = a % b`と等価

+=など演算と代入を同時に行う演算子を複合代入演算子(compound assignment operator)と呼ぶ。複合代入演算子と対比する場合は、=を単純代入演算子(simple assignment operator)と呼ぶ。

代入演算子の左辺に置けるのは変数のみで、リテラルや式は置けない。

2 += 1;    // エラー
a + 1 = 2; // エラー
a + b = 2; // エラー

2 += 1; // エラー

a + 1 = 2; // エラー

a + b = 2; // エラー

宣言文で使えるのは=のみで、+=などの複合代入演算子は使えない。

int a += 1 // エラー、=しか使えない

1	int a += 1 // エラー、=しか使えない

文字列に対する代入演算子

`a = b`	`a`の内容を`b`に代入する
`a += b`	`a`の文字列と`b`の文字列を結合した結果を`a`に代入する

左辺が変数でなければならない点、宣言文で+=が使えない点は数値に対する場合と同じ。

なお、左辺はString型の変数でなければならないが、右辺はString型のほかchar型でもよい。

String s = "ABC";
s += "DEF";
System.out.println(s); // ABCDEF

s += 'g';
System.out.println(s); // ABCDEFg

String s = "ABC";

s += "DEF";

System.out.println(s); // ABCDEF

s += 'g';

System.out.println(s); // ABCDEFg

Java – プリミティブ型 – 最大値・最小値

2021-06-13 / tau / コメントする

概要

数値表現可能なプリミティブ型の最大値・最小値は、それぞれのラッパークラスの定数として定義されている。

WrapperClass.MAX_VALUE
WrapperClass.MIN_VALUE

整数型、実数型、文字型で、それぞれの意味が異なる。

整数型の最大値・最小値

整数型の最大値・最小値は、それぞれのビット長で表現可能な符号付整数の最大値(正数)、最小値(負数)。

byte型

System.out.println(Byte.MAX_VALUE); // 127
System.out.println(Byte.MIN_VALUE); // -128

1 2	System.out.println(Byte.MAX_VALUE); // 127 System.out.println(Byte.MIN_VALUE); // -128

short型

System.out.println(Short.MAX_VALUE);  // 32767
System.out.println(Short.MIN_VALUE);  // -32768

1 2	System.out.println(Short.MAX_VALUE); // 32767 System.out.println(Short.MIN_VALUE); // -32768

int型

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Integer.MIN_VALUE);  // -2147483648

1 2	System.out.println(Integer.MAX_VALUE); // 2147483647 System.out.println(Integer.MIN_VALUE); // -2147483648

long型

System.out.println(Long.MAX_VALUE); // 9223372036854775807
System.out.println(Long.MIN_VALUE); // -9223372036854775808

1 2	System.out.println(Long.MAX_VALUE); // 9223372036854775807 System.out.println(Long.MIN_VALUE); // -9223372036854775808

整数型のオバーフロー／アンダーフロー

整数型の最大値を超える演算や最小値を下回る演算をすると、その方の範囲内のビットパターンで表現される値になる。

int iMax = Integer.MAX_VALUE;
System.out.println(iMax + 1);   // -2147483648
int iMin = Integer.MIN_VALUE;
System.out.println(iMin - 1);   // 2147483647

int iMax = Integer.MAX_VALUE;

System.out.println(iMax + 1); // -2147483648

int iMin = Integer.MIN_VALUE;

System.out.println(iMin - 1); // 2147483647

実数型の最大値・最小値

実数型の最大値・最小値は整数型と異なり、次の値。

最大値: 正の数で表現できる最大の数
最小値: 正の数で表現できる絶対値が最も小さい数

したがって、負の領域で表現可能な最小値は最大値のマイナス、負の領域で表現可能な絶対値が最小の数は最小値のマイナスになる。

float型

System.out.println(Float.MAX_VALUE);  // 3.4028235E38
System.out.println(Float.MIN_VALUE);  // 1.4E-45

1 2	System.out.println(Float.MAX_VALUE); // 3.4028235E38 System.out.println(Float.MIN_VALUE); // 1.4E-45

double型

System.out.println(Double.MAX_VALUE); // 1.7976931348623157E308
System.out.println(Double.MIN_VALUE); // 4.9E-324

1 2	System.out.println(Double.MAX_VALUE); // 1.7976931348623157E308 System.out.println(Double.MIN_VALUE); // 4.9E-324

実数型のオーバーフロー／アンダーフロー

実数型の最大値を超える演算をするとInfinityまたは-Infinityになる。

double dMaxP = Double.MAX_VALUE;
System.out.println(dMaxP * 2);    // Infinity
double dMaxN = -Double.MAX_VALUE;
System.out.println(dMaxN * 2);    // -Infinity

double dMaxP = Double.MAX_VALUE;

System.out.println(dMaxP * 2); // Infinity

double dMaxN = -Double.MAX_VALUE;

System.out.println(dMaxN * 2); // -Infinity

実数型の最小値の絶対値を下回る計算をすると、0.0または−0.0になる。

double dMinP = Double.MIN_VALUE;
System.out.println(dMinP / 2);   // 0.0
double dMinN = -Double.MIN_VALUE;
System.out.println(dMinN / 2);   // -0.0

double dMinP = Double.MIN_VALUE;

System.out.println(dMinP / 2); // 0.0

double dMinN = -Double.MIN_VALUE;

System.out.println(dMinN / 2); // -0.0

文字型の最大値・最小値

char型

char型の最小値は文字コード0の文字、最大値は文字コード65535の文字。

System.out.println((int)Character.MAX_VALUE); // 65535
System.out.println((int)Character.MIN_VALUE); // 0

1 2	System.out.println((int)Character.MAX_VALUE); // 65535 System.out.println((int)Character.MIN_VALUE); // 0

文字型のオーバーフロー／アンダーフロー

char型の最大値を超える演算や最小値を下回る演算をすると、それで表現可能な整数型に変換される。

char cMax = Character.MAX_VALUE;
System.out.println(cMax + 1);     // 65536
char cMin = Character.MIN_VALUE;
System.out.println(cMin - 1);     // -1

char cMax = Character.MAX_VALUE;

System.out.println(cMax + 1); // 65536

char cMin = Character.MIN_VALUE;

System.out.println(cMin - 1); // -1

Java – 演算子 – 算術演算子

2021-06-13 / tau / コメントする

概要

算術演算子はbyte型～long型などの整数や実数(float型double型)を対象とした演算子で、文字型のcharも演算対象になる。

＜単項演算子＞

`+a`	正符号、意味はない
`-a`	負符号、正負反転
`++a`	参照前インクリメント
`a++`	参照後インクリメント
`--a`	参照前デクリメント
`a--`	参照後デクリメント

＜二項演算子＞

`a + b`	加算
`a - b`	減算
`a * b`	乗算
`a / b`	除算
`a % b`	剰余

単項演算子

+：正符号

数値リテラルや数値型変数の前に置く。正数・負数とも符号は変わらず、実質意味を持たない。

int posInt = 2;
double posDbl = 3.0;
int negInt = -2;
double negDbl = -3.0;

System.out.println(+posInt); // 2
System.out.println(+negInt); // -2
System.out.println(+posDbl); // 3.0
System.out.println(+negDbl); // -3.0

int posInt = 2;

double posDbl = 3.0;

int negInt = -2;

double negDbl = -3.0;

System.out.println(+posInt); // 2

System.out.println(+negInt); // -2

System.out.println(+posDbl); // 3.0

System.out.println(+negDbl); // -3.0

－：負符号

数値リテラルや数値型変数の前に置き、符号を反転させる。

符号演算子の連続

単項演算子は交互に連続して書くことができて、その結果は負符号’-‘が偶数回なら’+‘と同じ、奇数回なら’-‘と同じ結果になる。

ただしその中に--や++のように連続した符号があると、インクリメント／デクリメント演算子と解釈されてエラーになる。

System.out.println(-+-+-5); // -5
System.out.println(-+--5); // コンパイルエラー：演算 ++/-- の引数が無効ですいいんく

1 2	System.out.println(-+-+-5); // -5 System.out.println(-+--5); // コンパイルエラー：演算 ++/-- の引数が無効ですいいんく

++/–：インクリメント／デクリメント

++を変数の直前に書くと「変数が評価される前に」変数の内容が1増加する
++を変数の後に書くと「変数が評価された後に」変数の内容が1減少する
演算子と変数の間に空白が入ってもよい。

整数の例

以下の例では、演算子が前置された場合は表示前にインクリメント／デクリメントされ、後置された場合は表示後にインクリメント／デクリメントされる。

int n = 0;
System.out.println(++n);  // 1
System.out.println(n++);  // 1
System.out.println(++ n); // 3
System.out.println(n ++); // 3
System.out.println(n);    // 4

n=0;
System.out.println(--n);  // -1
System.out.println(n--);  // -1
System.out.println(-- n); // -3
System.out.println(n --); // -3
System.out.println(n);    // -4

int n = 0;

System.out.println(++n); // 1

System.out.println(n++); // 1

System.out.println(++ n); // 3

System.out.println(n ++); // 3

System.out.println(n); // 4

n=0;

System.out.println(--n); // -1

System.out.println(n--); // -1

System.out.println(-- n); // -3

System.out.println(n --); // -3

System.out.println(n); // -4

また、以下の例では二項演算子の項にインクリメント／デクリメント演算子を使った例。

n = 3;
int result = n++ + ++n - n--;
System.out.println(result+ ", " + n); // 3, 4

n = 3;

int result = n++ + ++n - n--;

System.out.println(result+ ", " + n); // 3, 4

上記の例をnの変化で表すと以下の様になる。

3(→4) + →5 – 5(→4) = 3(4)

実数の例

実数の場合も++で1.0増加、--で1.0減少になるが、計算誤差が出る。

double d = 1.3;
System.out.println(++d); // 2.3
System.out.println(--d); // 1.2999999999999998
System.out.println(--d); // 0.2999999999999998

double d = 1.3;

System.out.println(++d); // 2.3

System.out.println(--d); // 1.2999999999999998

System.out.println(--d); // 0.2999999999999998

char型の例

char型にも適用可能で、インクリメントで1文字進み、デクリメントで1文字戻る。

char c = 'ぁ';
System.out.print(++c);
System.out.print(++c);
System.out.print(++c);
System.out.print(--c);
System.out.println();
// あぃいぃ

char c = 'ぁ';

System.out.print(++c);

System.out.print(--c);

System.out.println();

// あぃいぃ

二項演算子

四則演算

四則演算は多言語と同じ記号で、整数・実数の関係も同じ。整数同士の演算は整数で桁数が多い方に自動的にキャストされ、2項のうちいずれかでも実数なら結果も実数になる。

+：加算

System.out.println(7 + 2);    // 9
System.out.println(7.0 + 2);  // 9.0
System.out.println(7 + 2.0);  // 9.0

System.out.println(7 + 2); // 9

System.out.println(7.0 + 2); // 9.0

System.out.println(7 + 2.0); // 9.0

-：減算

System.out.println(7 - 2);    // 5
System.out.println(7.0 - 2);  // 5.0
System.out.println(7 - 2.0);  // 5.0

System.out.println(7 - 2); // 5

System.out.println(7.0 - 2); // 5.0

System.out.println(7 - 2.0); // 5.0

*：乗算

System.out.println(7 * 2);    // 14
System.out.println(7.0 * 2);  // 14.0
System.out.println(7 * 2.0);  // 14.0

System.out.println(7 * 2); // 14

System.out.println(7.0 * 2); // 14.0

System.out.println(7 * 2.0); // 14.0

/：除算

System.out.println(7 / 2);    // 3
System.out.println(7.0 / 2);  // 3.5
System.out.println(7 / 2.0);  // 3.5

System.out.println(7 / 2); // 3

System.out.println(7.0 / 2); // 3.5

System.out.println(7 / 2.0); // 3.5

%：剰余

aをbで割った時の剰余(余り)をa % bで与える。実数表現でも整数商に対する剰余が計算される。

System.out.println(7 % 2);    // 1
System.out.println(7.0 % 2);  // 1.0
System.out.println(7 % 2.0);  // 1.0

System.out.println(7 % 2); // 1

System.out.println(7.0 % 2); // 1.0

System.out.println(7 % 2.0); // 1.0

除数・被除数が小数部を持つ場合、整数商に対する剰余が実数で計算される。

System.out.println(5 % 2.5);    // 0.0
System.out.println(5 % 1.5);    // 0.5
System.out.println(5.5 % 1.5);  // 1.0

System.out.println(5 % 2.5); // 0.0

System.out.println(5 % 1.5); // 0.5

System.out.println(5.5 % 1.5); // 1.0

除数・被除数が負数の場合は、商と剰余の以下の式から考える。

(1) $\begin{equation*} a / b = q, \; a \% b = r \quad \Leftrightarrow \quad a = b q + r \end{equation*}$

たとえば以下のように。

(2) $\begin{equation*} -7 \% (-2) = -1 \quad \Leftarrow \quad -7 = -2 \times 3 - 1 \end{equation*}$

System.out.println(-7 % 2);     // -1
System.out.println(7 % (-2));   // 1
System.out.println(-7 % (-2));  // -1

System.out.println(-7 % 2); // -1

System.out.println(7 % (-2)); // 1

System.out.println(-7 % (-2)); // -1

ゼロによる除算

整数除算でゼロで割ると実行時例外となる。剰余も除算を行っているので同じ。

System.out.println(7 % 0);
// Exception in thread "main" java.lang.ArithmeticException: / by zero

System.out.println(7 % 0);
// Exception in thread "main" java.lang.ArithmeticException: / by zero

System.out.println(7 % 0);

// Exception in thread "main" java.lang.ArithmeticException: / by zero

System.out.println(7 % 0);

// Exception in thread "main" java.lang.ArithmeticException: / by zero

浮動小数点演算の場合にゼロで割ると例外にならず、結果はInfinityとなる。剰余計算の場合は結果はNaN

System.out.println(1.0 / 0);  // Infinity

System.out.println(7.0 % 0);  // NaN

System.out.println(1.0 / 0); // Infinity

System.out.println(7.0 % 0); // NaN

べき乗

べき乗の演算子はなく、必要ならMathpow()メソッドを使う。

System.out.println(Math.pow(2, 3));   // 8.0
System.out.println(Math.pow(-2, 3));  // -8.0
System.out.println(Math.pow(2, -3));  // 8.0

System.out.println(Math.pow(2, 3)); // 8.0

System.out.println(Math.pow(-2, 3)); // -8.0

System.out.println(Math.pow(2, -3)); // 8.0

Java – 配列 – 同一性・等価性

2021-06-04 / tau / コメントする

概要

配列の同一性は変数が指しているインスタンスが同じかどうかのみによるが、等価性の場合は末端の要素一つ一つが等価かどうかを判定することになる。

Javaの配列で等価性を判定する場合、1次元配列はArrays.equals()で等価性を判定できるが、2次元以上の配列になるとArrays.deepEquals()で判定しなければならない。

配列のコピーでもディープコピーができるメソッドがなくループで回さないといけないなど、Javaの配列は使いにくい。というよりも、下手に使うと思わぬところでミスの要因になりそう。

1次元配列

同一性(==)

配列変数が指している対象が同じかどうか。内容が同じでも変数が指しているインスタンスが異なる場合は同一にならない。

以下の例ではarray1とarray2が同じ配列インスタンスを指している(ハッシュ値が等しい)ので、内容が変わっても同一。

一方で変更前のarray1とarray4、変更後のarray1とarray3は、内容が同じでも配列のインスタンスが異なるため、同一とは判定されない。

public class ArrayEquality {
  String[] array1 = {"A", "B", "C"};
  String[] array2 = array1;
  String[] array3 = {"X", "Y", "Z"};
  String[] array4 = {"A", "B", "C"};

  public void identity() {
    System.out.println(array1); // [Ljava.lang.String;@7637f22
    System.out.println(array2); // [Ljava.lang.String;@7637f22
    System.out.println(array3); // [Ljava.lang.String;@3830f1c0
    System.out.println(array4); // [Ljava.lang.String;@39ed3c8d

    System.out.println(array1 == array2); // true
    System.out.println(array1 == array3); // false
    System.out.println(array1 == array4); // false

    array1[0] = "X";
    array1[1] = "Y";
    array1[2] = "Z";

    System.out.println(array1 == array2); // true
    System.out.println(array1 == array3); // false
    System.out.println(array1 == array4); // false
  }

  public static void main(String[] args) {
    ArrayEquality app = new ArrayEquality();
    app.identity();
  }
}

public class ArrayEquality {

String[] array1 = {"A", "B", "C"};

String[] array2 = array1;

String[] array3 = {"X", "Y", "Z"};

String[] array4 = {"A", "B", "C"};

public void identity() {

System.out.println(array1); // [Ljava.lang.String;@7637f22

System.out.println(array2); // [Ljava.lang.String;@7637f22

System.out.println(array3); // [Ljava.lang.String;@3830f1c0

System.out.println(array4); // [Ljava.lang.String;@39ed3c8d

System.out.println(array1 == array2); // true

System.out.println(array1 == array3); // false

System.out.println(array1 == array4); // false

array1[0] = "X";

array1[1] = "Y";

array1[2] = "Z";

System.out.println(array1 == array2); // true

System.out.println(array1 == array3); // false

System.out.println(array1 == array4); // false

}

public static void main(String[] args) {

ArrayEquality app = new ArrayEquality();

app.identity();

}

等価性(Array.equals)

配列の内容が同じかどうか。異なる配列インスタンスでも内容が同じなら等価。同値性とも。

配列の等価性をチェックするにはArrays.equals()メソッドを使う。

以下の例では、array1とarray2は同一であり等価。array1の変更前はarray3と等価だが、変更後にはarray4と等価になる。

import java.util.Arrays;

public class ArrayEquality {
  String[] array1 = {"A", "B", "C"};
  String[] array2 = array1;
  String[] array3 = {"X", "Y", "Z"};
  String[] array4 = {"A", "B", "C"};

  public void arraysEquals() {
    System.out.println(Arrays.equals(array1, array2));  // true
    System.out.println(Arrays.equals(array1, array3));  // false
    System.out.println(Arrays.equals(array1, array4));  // true

    array1[0] = "X";
    array1[1] = "Y";
    array1[2] = "Z";

    System.out.println(Arrays.equals(array1, array2));  // true
    System.out.println(Arrays.equals(array1, array3));  // true
    System.out.println(Arrays.equals(array1, array4));  // false
  }

  public static void main(String[] args) {
    ArrayEquality app = new ArrayEquality();
    app.arraysEquals();
  }
}

import java.util.Arrays;

public class ArrayEquality {

String[] array1 = {"A", "B", "C"};

String[] array2 = array1;

String[] array3 = {"X", "Y", "Z"};

String[] array4 = {"A", "B", "C"};

public void arraysEquals() {

System.out.println(Arrays.equals(array1, array2)); // true

System.out.println(Arrays.equals(array1, array3)); // false

System.out.println(Arrays.equals(array1, array4)); // true

array1[0] = "X";

array1[1] = "Y";

array1[2] = "Z";

System.out.println(Arrays.equals(array1, array2)); // true

System.out.println(Arrays.equals(array1, array3)); // true

System.out.println(Arrays.equals(array1, array4)); // false

}

public static void main(String[] args) {

ArrayEquality app = new ArrayEquality();

app.arraysEquals();

}

equals()メソッドは要注意

配列もオブジェクトとしてequals()メソッドを備えているが、これは同一性の判定しかせず、等価性の判定には使えない。

以下の例で、結果が==のときと同じになっているのが確認できる。

public class ArrayEquality {
  String[] array1 = {"A", "B", "C"};
  String[] array2 = array1;
  String[] array3 = {"X", "Y", "Z"};
  String[] array4 = {"A", "B", "C"};

  public void equalsMethod() {
    System.out.println(array1.equals(array2));  // true
    System.out.println(array1.equals(array3));  // false
    System.out.println(array1.equals(array4));  // false

    array1[0] = "X";
    array1[1] = "Y";
    array1[2] = "Z";

    System.out.println(array1.equals(array2));  // true
    System.out.println(array1.equals(array3));  // false
    System.out.println(array1.equals(array4));  // false
  }

  public static void main(String[] args) {
    ArrayEquality app = new ArrayEquality();
    app.equalsMethod();
  }
}

public class ArrayEquality {

String[] array1 = {"A", "B", "C"};

String[] array2 = array1;

String[] array3 = {"X", "Y", "Z"};

String[] array4 = {"A", "B", "C"};

public void equalsMethod() {

System.out.println(array1.equals(array2)); // true

System.out.println(array1.equals(array3)); // false

System.out.println(array1.equals(array4)); // false

array1[0] = "X";

array1[1] = "Y";

array1[2] = "Z";

System.out.println(array1.equals(array2)); // true

System.out.println(array1.equals(array3)); // false

System.out.println(array1.equals(array4)); // false

}

public static void main(String[] args) {

ArrayEquality app = new ArrayEquality();

app.equalsMethod();

}

多次元配列

Array.equals()も要注意

Arrays.equals()はclone()の挙動と似ていて、

1次元目の各要素が同一なら結果はtrue
1次元目の各要素のいずれかが同一でないなら結果はfalse

多次元配列でArray.equals()を使うと、2次元目の要素配列が同一であればtrueとなり、同一でなければ内容が同じでもfalseとなる。

以下の例では、

array2d1とarray2d2は元のインスタンスが同一であり等価
array2d1からclone()で作られたarray2d3は、元のインスタンスは異なるが、それが指している要素が同じなので同一ではないが等価
array2d3もarray2d4も、元のインスタンスから要素に至るまでarray2d1と異なるため、変更前／変更後に内容が同じになっても等価と判定されない

Arrays.equals()の等価性判定は1次元配列にしか使えない

import java.util.Arrays;

public class ArrayEquality {
  String[][] array2d1 = {{"A", "B"}, {"C", "D"}};
  String[][] array2d2 = array2d1;
  String[][] array2d3 = array2d1.clone();
  String[][] array2d4 = {{"W", "X"}, {"Y", "Z"}};
  String[][] array2d5 = {{"A", "B"}, {"C", "D"}};

  public void arraysEquals2d() {
    System.out.println(array2d1 + " " + Arrays.toString(array2d1));
    System.out.println(array2d2 + " " + Arrays.toString(array2d2));
    System.out.println(array2d3 + " " + Arrays.toString(array2d3));
    System.out.println(array2d4 + " " + Arrays.toString(array2d4));
    System.out.println(array2d5 + " " + Arrays.toString(array2d5));
    // [[Ljava.lang.String;@7637f22 [[Ljava.lang.String;@4926097b, [Ljava.lang.String;@762efe5d]
    // [[Ljava.lang.String;@7637f22 [[Ljava.lang.String;@4926097b, [Ljava.lang.String;@762efe5d]
    // [[Ljava.lang.String;@71dac704 [[Ljava.lang.String;@4926097b, [Ljava.lang.String;@762efe5d]
    // [[Ljava.lang.String;@123772c4 [[Ljava.lang.String;@2d363fb3, [Ljava.lang.String;@7d6f77cc]
    // [[Ljava.lang.String;@5aaa6d82 [[Ljava.lang.String;@73a28541, [Ljava.lang.String;@6f75e721]

    System.out.println(Arrays.equals(array2d1, array2d2));  // true
    System.out.println(Arrays.equals(array2d1, array2d3));  // true
    System.out.println(Arrays.equals(array2d1, array2d4));  // false
    System.out.println(Arrays.equals(array2d1, array2d5));  // false

    array2d1[0][0] = "W";
    array2d1[0][1] = "X";
    array2d1[1][0] = "Y";
    array2d1[0][1] = "Z";

    System.out.println(Arrays.equals(array2d1, array2d2));  // true
    System.out.println(Arrays.equals(array2d1, array2d3));  // true
    System.out.println(Arrays.equals(array2d1, array2d4));  // false
    System.out.println(Arrays.equals(array2d1, array2d5));  // false
  }

  public static void main(String[] args) {
    ArrayEquality app = new ArrayEquality();
    app.arraysEquals2d();
  }
}

import java.util.Arrays;

public class ArrayEquality {

String[][] array2d1 = {{"A", "B"}, {"C", "D"}};

String[][] array2d2 = array2d1;

String[][] array2d3 = array2d1.clone();

String[][] array2d4 = {{"W", "X"}, {"Y", "Z"}};

String[][] array2d5 = {{"A", "B"}, {"C", "D"}};

public void arraysEquals2d() {

System.out.println(array2d1 + " " + Arrays.toString(array2d1));

System.out.println(array2d2 + " " + Arrays.toString(array2d2));

System.out.println(array2d3 + " " + Arrays.toString(array2d3));

System.out.println(array2d4 + " " + Arrays.toString(array2d4));

System.out.println(array2d5 + " " + Arrays.toString(array2d5));

// [[Ljava.lang.String;@7637f22 [[Ljava.lang.String;@4926097b, [Ljava.lang.String;@762efe5d]

// [[Ljava.lang.String;@71dac704 [[Ljava.lang.String;@4926097b, [Ljava.lang.String;@762efe5d]

// [[Ljava.lang.String;@123772c4 [[Ljava.lang.String;@2d363fb3, [Ljava.lang.String;@7d6f77cc]

// [[Ljava.lang.String;@5aaa6d82 [[Ljava.lang.String;@73a28541, [Ljava.lang.String;@6f75e721]

System.out.println(Arrays.equals(array2d1, array2d2)); // true

System.out.println(Arrays.equals(array2d1, array2d3)); // true

System.out.println(Arrays.equals(array2d1, array2d4)); // false

System.out.println(Arrays.equals(array2d1, array2d5)); // false

array2d1[0][0] = "W";

array2d1[0][1] = "X";

array2d1[1][0] = "Y";

array2d1[0][1] = "Z";

System.out.println(Arrays.equals(array2d1, array2d2)); // true

System.out.println(Arrays.equals(array2d1, array2d3)); // true

System.out.println(Arrays.equals(array2d1, array2d4)); // false

System.out.println(Arrays.equals(array2d1, array2d5)); // false

}

public static void main(String[] args) {

ArrayEquality app = new ArrayEquality();

app.arraysEquals2d();

}

深層比較(deepEquals)

Arrays.deepEquals()は、引数の2つの配列の要素の等価性を再帰的に判定する。

import java.util.Arrays;

public class ArrayEquality {
  String[][] array2d1 = {{"A", "B"}, {"C", "D"}};
  String[][] array2d2 = array2d1;
  String[][] array2d3 = array2d1.clone();
  String[][] array2d4 = {{"W", "X"}, {"Y", "Z"}};
  String[][] array2d5 = {{"A", "B"}, {"C", "D"}};

  public void arraysDeepEquals2d() {
    System.out.println(Arrays.deepEquals(array2d1, array2d2));  // true
    System.out.println(Arrays.deepEquals(array2d1, array2d3));  // true
    System.out.println(Arrays.deepEquals(array2d1, array2d4));  // false
    System.out.println(Arrays.deepEquals(array2d1, array2d5));  // true

    array2d1[0][0] = "W";
    array2d1[0][1] = "X";
    array2d1[1][0] = "Y";
    array2d1[1][1] = "Z";

    System.out.println(Arrays.deepEquals(array2d1, array2d2));  // true
    System.out.println(Arrays.deepEquals(array2d1, array2d3));  // true
    System.out.println(Arrays.deepEquals(array2d1, array2d4));  // true
    System.out.println(Arrays.deepEquals(array2d1, array2d5));  // false
  }

  public static void main(String[] args) {
    ArrayEquality app = new ArrayEquality();
    app.arraysDeepEquals2d();
  }
}

import java.util.Arrays;

public class ArrayEquality {

String[][] array2d1 = {{"A", "B"}, {"C", "D"}};

String[][] array2d2 = array2d1;

String[][] array2d3 = array2d1.clone();

String[][] array2d4 = {{"W", "X"}, {"Y", "Z"}};

String[][] array2d5 = {{"A", "B"}, {"C", "D"}};

public void arraysDeepEquals2d() {

System.out.println(Arrays.deepEquals(array2d1, array2d2)); // true

System.out.println(Arrays.deepEquals(array2d1, array2d3)); // true

System.out.println(Arrays.deepEquals(array2d1, array2d4)); // false

System.out.println(Arrays.deepEquals(array2d1, array2d5)); // true

array2d1[0][0] = "W";

array2d1[0][1] = "X";

array2d1[1][0] = "Y";

array2d1[1][1] = "Z";

System.out.println(Arrays.deepEquals(array2d1, array2d2)); // true

System.out.println(Arrays.deepEquals(array2d1, array2d3)); // true

System.out.println(Arrays.deepEquals(array2d1, array2d4)); // true

System.out.println(Arrays.deepEquals(array2d1, array2d5)); // false

}

public static void main(String[] args) {

ArrayEquality app = new ArrayEquality();

app.arraysDeepEquals2d();

}

Java – 配列 – コピー

2021-06-04 / tau / コメントする

概要

Javaにおける配列のコピーについて整理する。

1次元配列はclone()メソッドかSystem.arraycopy()メソッド
多次元配列は次元分forでネストしてclone()かSystem.arraycopy()

Javaの配列は扱いづらく、deepToString()やdeepEquals()はあるのにdeepCopy()がないのが不思議。

代入(assignment)

配列変数を他の変数に代入した場合、代入先の変数が元の変数と同じ配列を参照する。一方での変更が他方の結果にも反映される。

下記コードで、2つの配列のハッシュ値が同じこと、片方の変更が他方にも反映されることが確認できる。

import java.util.Arrays;

public class ArrayCopy {
  public void assignment() {
    String[] array = {"A", "B", "C"};
    String[] arrayAssigned = array;

    System.out.println(array);
    System.out.println(arrayAssigned);
    // [Ljava.lang.String;@7637f22
    // [Ljava.lang.String;@7637f22

    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayAssigned));
    // [A, B, C]
    // [A, B, C]

    array[0] = "X";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayAssigned));
    // [X, B, C]
    // [X, B, C]

    arrayAssigned[1] = "Y";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayAssigned));
    // [X, Y, C]
    // [X, Y, C]
  }

  public static void main(String[] args) {
    ArrayCopy app = new ArrayCopy();
    app.assignment();
  }
}

import java.util.Arrays;

public class ArrayCopy {

public void assignment() {

String[] array = {"A", "B", "C"};

String[] arrayAssigned = array;

System.out.println(array);

System.out.println(arrayAssigned);

// [Ljava.lang.String;@7637f22

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

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

// [A, B, C]

array[0] = "X";

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

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

// [X, B, C]

arrayAssigned[1] = "Y";

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

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

// [X, Y, C]

}

public static void main(String[] args) {

ArrayCopy app = new ArrayCopy();

app.assignment();

}

clone()

clone()メソッドは配列の要素の「内容」を順次コピーして新たな配列を返す。一方の配列への変更は他方に影響しない。プリミティブ型の配列でも使える。

以下のコードで、2つの変数のハッシュ値が異なること、一方の変更が他方に影響していないことが確認できる。

import java.util.Arrays;

public class ArrayCopy {
  public void cloning() {
    String[] array = {"A", "B", "C"};
    String[] arrayCloned = array.clone();

    System.out.println(array);
    System.out.println(arrayCloned);
    // [Ljava.lang.String;@7637f22
    // [Ljava.lang.String;@3830f1c0

    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCloned));
    // [A, B, C]
    // [A, B, C]

    array[0] = "X";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCloned));
    // [X, B, C]
    // [A, B, C]

    arrayCloned[1] = "Y";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCloned));
    // [X, B, C]
    // [A, Y, C]
  }

  public static void main(String[] args) {
    ArrayCopy app = new ArrayCopy();
    app.cloning();
  }
}

import java.util.Arrays;

public class ArrayCopy {

public void cloning() {

String[] array = {"A", "B", "C"};

String[] arrayCloned = array.clone();

System.out.println(array);

System.out.println(arrayCloned);

// [Ljava.lang.String;@7637f22

// [Ljava.lang.String;@3830f1c0

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

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

// [A, B, C]

array[0] = "X";

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

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

// [X, B, C]

// [A, B, C]

arrayCloned[1] = "Y";

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

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

// [X, B, C]

// [A, Y, C]

}

public static void main(String[] args) {

ArrayCopy app = new ArrayCopy();

app.cloning();

}

System.arraycopy()

System.arraycopy()メソッドは引数にコピー元・コピー先の配列とコピー位置、コピー長さを指定して、コピー先にはコピー元の要素が複製された新たな配列が与えられる。clone()と同じく、一方の配列への変更は他方に影響しない。

System.copy(元配列, 元開始位置, 先配列, 先開始位置, コピー長)

import java.util.Arrays;

public class ArrayCopy {
  public void copy() {
    String[] array = {"A", "B", "C"};
    String[] arrayCopied = new String[array.length];
    System.arraycopy(array, 0, arrayCopied, 0, array.length);

    System.out.println(array);
    System.out.println(arrayCopied);
    // [Ljava.lang.String;@7637f22
    // [Ljava.lang.String;@3830f1c0

    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCopied));
    // [A, B, C]
    // [A, B, C]

    array[0] = "X";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCopied));
    // [X, B, C]
    // [A, B, C]

    arrayCopied[1] = "Y";
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCopied));
    // [X, B, C]
    // [A, Y, C]
  }

  public static void main(String[] args) {
    ArrayCopy app = new ArrayCopy();
    app.copy();
  }
}

import java.util.Arrays;

public class ArrayCopy {

public void copy() {

String[] array = {"A", "B", "C"};

String[] arrayCopied = new String[array.length];

System.arraycopy(array, 0, arrayCopied, 0, array.length);

System.out.println(array);

System.out.println(arrayCopied);

// [Ljava.lang.String;@7637f22

// [Ljava.lang.String;@3830f1c0

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

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

// [A, B, C]

array[0] = "X";

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

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

// [X, B, C]

// [A, B, C]

arrayCopied[1] = "Y";

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

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

// [X, B, C]

// [A, Y, C]

}

public static void main(String[] args) {

ArrayCopy app = new ArrayCopy();

app.copy();

}

clone()はシャローコピー

多次元配列をclone()でコピーしてもディープコピーにはならない。一方の配列への変更が他方に影響する。

以下のコードで、1次元目は違うハッシュ値でコピーされているが、それぞれが持っている要素配列はそのままのハッシュ値でコピーされている。

これは、clone()で元の配列の要素(配列)が新たなインスタンスとして複製されるが、その要素は単に代入されるだけで再帰的に複製されないため。

import java.util.Arrays;

public class ArrayCopy {
  public void multiDimShallowClone() {
    String[][] array = {{"A", "B"}, {"C", "D"}};
    String[][] arrayCloned = array.clone();

    System.out.println(array);
    System.out.println(arrayCloned);
    // [[Ljava.lang.String;@7637f22
    // [[Ljava.lang.String;@3830f1c0

    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCloned));
    // [[Ljava.lang.String;@39ed3c8d, [Ljava.lang.String;@71dac704]
    // [[Ljava.lang.String;@39ed3c8d, [Ljava.lang.String;@71dac704]

    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[A, B], [C, D]]
    // [[A, B], [C, D]]

    array[0][0] = "X";
    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[X, B], [C, D]]
    // [[X, B], [C, D]]

    arrayCloned[1][0] = "Y";
    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[X, B], [Y, D]]
    // [[X, B], [Y, D]]
  }

  public static void main(String[] args) {
    ArrayCopy app = new ArrayCopy();
    app.multiDimShallowClone();
  }
}

import java.util.Arrays;

public class ArrayCopy {

public void multiDimShallowClone() {

String[][] array = {{"A", "B"}, {"C", "D"}};

String[][] arrayCloned = array.clone();

System.out.println(array);

System.out.println(arrayCloned);

// [[Ljava.lang.String;@7637f22

// [[Ljava.lang.String;@3830f1c0

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

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

// [[Ljava.lang.String;@39ed3c8d, [Ljava.lang.String;@71dac704]

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[A, B], [C, D]]

array[0][0] = "X";

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[X, B], [C, D]]

arrayCloned[1][0] = "Y";

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[X, B], [Y, D]]

}

public static void main(String[] args) {

ArrayCopy app = new ArrayCopy();

app.multiDimShallowClone();

}

多次元配列のディープコピー

多次元配列をディープコピーするには、最後の要素までclone()で複製する必要がある。

2つの配列を同時に扱うのにPythonのzipのような機能がないので、カウンターで回さないといけない。

import java.util.Arrays;

public class ArrayCopy {
  public void multiDimDeepClone() {
    String[][] array = {{"A", "B"}, {"C", "D"}};
    String[][] arrayCloned = new String[array.length][];
    for (int i = 0; i < array.length; i++) {
      arrayCloned[i] = array[i].clone();
    }

    System.out.println(array);
    System.out.println(arrayCloned);
    // [[Ljava.lang.String;@7637f22
    // [[Ljava.lang.String;@3830f1c0

    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(arrayCloned));
    // [[Ljava.lang.String;@39ed3c8d, [Ljava.lang.String;@71dac704]
    // [[Ljava.lang.String;@123772c4, [Ljava.lang.String;@2d363fb3]

    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[A, B], [C, D]]
    // [[A, B], [C, D]]

    array[0][0] = "X";
    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[X, B], [C, D]]
    // [[A, B], [C, D]]

    arrayCloned[1][0] = "Y";
    System.out.println(Arrays.deepToString(array));
    System.out.println(Arrays.deepToString(arrayCloned));
    // [[X, B], [C, D]]
    // [[A, B], [Y, D]]
  }

  public static void main(String[] args) {
    ArrayCopy app = new ArrayCopy();
    app.multiDimDeepClone();
  }
}

import java.util.Arrays;

public class ArrayCopy {

public void multiDimDeepClone() {

String[][] array = {{"A", "B"}, {"C", "D"}};

String[][] arrayCloned = new String[array.length][];

for (int i = 0; i < array.length; i++) {

arrayCloned[i] = array[i].clone();

}

System.out.println(array);

System.out.println(arrayCloned);

// [[Ljava.lang.String;@7637f22

// [[Ljava.lang.String;@3830f1c0

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

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

// [[Ljava.lang.String;@39ed3c8d, [Ljava.lang.String;@71dac704]

// [[Ljava.lang.String;@123772c4, [Ljava.lang.String;@2d363fb3]

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[A, B], [C, D]]

array[0][0] = "X";

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[X, B], [C, D]]

// [[A, B], [C, D]]

arrayCloned[1][0] = "Y";

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

System.out.println(Arrays.deepToString(arrayCloned));

// [[X, B], [C, D]]

// [[A, B], [Y, D]]

}

public static void main(String[] args) {

ArrayCopy app = new ArrayCopy();

app.multiDimDeepClone();

}

Java – 配列 – Object配列

2021-06-03 / tau / コメントする

概要

Object配列は、任意のオブジェクトを要素とすることができ、異なる型の要素を持つことができる。

1次元のObject配列

イニシャライザー

配列の型をObject[]とすると、任意の型・クラスの値を要素に持つことができる。

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Random;

public class ObjectArray {
  public void initializer() {
    Object[] array = {1, "two", new Random().nextInt(1000), LocalDate.of(2000, 7, 15)};

    System.out.println(Arrays.toString(array));
    // [1, two, 1808318309, 2021-05-27]
  }

  public static void main(String[] args) {
    ObjectArray app = new ObjectArray();
    app.initializer();
  }
}

import java.time.LocalDate;

import java.util.Arrays;

import java.util.Random;

public class ObjectArray {

public void initializer() {

Object[] array = {1, "two", new Random().nextInt(1000), LocalDate.of(2000, 7, 15)};

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

// [1, two, 1808318309, 2021-05-27]

}

public static void main(String[] args) {

ObjectArray app = new ObjectArray();

app.initializer();

}

newによる初期化

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Random;

public class ObjectArray {
  public void initByNew() {
    Object[] array = new Object[4];

    array[0] = 1;
    array[1] = "two";
    array[2] = new Random().nextInt(1000);
    array[3] = LocalDate.of(2000, 7, 15);

    System.out.println(Arrays.toString(array));
    // [1, two, 1025805776, 2021-05-27]
  }

  public static void main(String[] args) {
    ObjectArray app = new ObjectArray();
    app.initByNew();
  }
}

import java.time.LocalDate;

import java.util.Arrays;

import java.util.Random;

public class ObjectArray {

public void initByNew() {

Object[] array = new Object[4];

array[0] = 1;

array[1] = "two";

array[2] = new Random().nextInt(1000);

array[3] = LocalDate.of(2000, 7, 15);

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

// [1, two, 1025805776, 2021-05-27]

}

public static void main(String[] args) {

ObjectArray app = new ObjectArray();

app.initByNew();

}

多次元のObject配列

多次元のObject配列をイニシャライザーで宣言することもできるが、ダイナミックに要素を追加していくこともできる。

以下の例では、まず1次元のObject配列を要素数を与えて生成し、1つ目の要素はString型の要素、2つ目と3つ目はObject配列を要素配列として生成してセットしている。

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Random;

public class ObjectArray {
  public void twoDimensional() {
    Object[] array = new Object[3];
    array[0] = "one";
    array[1] = new Object[] {2, "three", '四'};
    array[2] = new Object[] {new Random().nextInt(1000), LocalDate.of(2000, 7, 15)};

    System.out.println(Arrays.deepToString(array));
    // [one, [2, three, 四], [987, 2000-07-15]]
  }

  public static void main(String[] args) {
    ObjectArray app = new ObjectArray();
    app.twoDimensional();
  }
}

import java.time.LocalDate;

import java.util.Arrays;

import java.util.Random;

public class ObjectArray {

public void twoDimensional() {

Object[] array = new Object[3];

array[0] = "one";

array[1] = new Object[] {2, "three", '四'};

array[2] = new Object[] {new Random().nextInt(1000), LocalDate.of(2000, 7, 15)};

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

// [one, [2, three, 四], [987, 2000-07-15]]

}

public static void main(String[] args) {

ObjectArray app = new ObjectArray();

app.twoDimensional();

}

Java – 配列 – 多次元配列

2021-06-03 / tau / コメントする

初期化

多次元配列の型はtype[][]...で表し、1次元と同じくイニシャライザーやnewで初期化できる。

newとイニシャライザーを使うと、要素配列を個別に定義することが可能。

import java.util.Arrays;

public class ArrayMultiDimensional {
  public static void main(String[] args) {
    // イニシャライザーによる初期化
    int[][] intArray = {{0, 1}, {2, 3, 4}};
    System.out.println(Arrays.deepToString(intArray));
    // [[0, 1], [2, 3, 4]]

    // newとイニシャライザーによる初期化
    intArray = new int[][] {{5, 6, 7}, {8, 9}};
    System.out.println(Arrays.deepToString(intArray));
    // [[5, 6, 7], [8, 9]]

    // newとイニシャライザーによる要素配列ごとの初期化
    intArray = new int[3][];
    intArray[0] = new int[] {1, 2, 3};
    intArray[1] = new int[] {4, 5, 6};
    intArray[2] = new int[] {7, 8, 9};
    System.out.println(Arrays.deepToString(intArray));
    // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  }

}

import java.util.Arrays;

public class ArrayMultiDimensional {

public static void main(String[] args) {

// イニシャライザーによる初期化

int[][] intArray = {{0, 1}, {2, 3, 4}};

System.out.println(Arrays.deepToString(intArray));

// [[0, 1], [2, 3, 4]]

// newとイニシャライザーによる初期化

intArray = new int[][] {{5, 6, 7}, {8, 9}};

System.out.println(Arrays.deepToString(intArray));

// [[5, 6, 7], [8, 9]]

// newとイニシャライザーによる要素配列ごとの初期化

intArray = new int[3][];

intArray[0] = new int[] {1, 2, 3};

intArray[1] = new int[] {4, 5, 6};

intArray[2] = new int[] {7, 8, 9};

System.out.println(Arrays.deepToString(intArray));

// [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

}

内容表示

多次元配列を表示するには、ループで回すかArrays.deepToString()を使う(Java – 配列 – 内容表示)。

import java.util.Arrays;

public class ArrayMultiDim {
  public void display() {
    int[][] intArray = {{0, 1}, {2, 3, 4}};

    for (int[] subarray: intArray) {
      for (int e: subarray) {
        System.out.print(e + " ");
      }
      System.out.println();
    }
    // 0 1 
    // 2 3 4 

    System.out.println(Arrays.deepToString(intArray));
    // [[0, 1], [2, 3, 4]]
  }

  public static void main(String[] args) {
    ArrayMultiDim app = new ArrayMultiDim();
    app.display();
  }
}

import java.util.Arrays;

public class ArrayMultiDim {

public void display() {

int[][] intArray = {{0, 1}, {2, 3, 4}};

for (int[] subarray: intArray) {

for (int e: subarray) {

System.out.print(e + " ");

}

System.out.println();

}

// 0 1

// 2 3 4

System.out.println(Arrays.deepToString(intArray));

// [[0, 1], [2, 3, 4]]

}

public static void main(String[] args) {

ArrayMultiDim app = new ArrayMultiDim();

app.display();

}

Java – 配列 – 内容表示

2021-06-03 / tau / コメントする

そのままだとオブジェクトの表示

Javaの配列をそのまま表示しようとすると、参照値が表示される。

int[] intArray = {0, 2, 4, 6};

System.out.println(intArray);
// [I@7637f22

int[] intArray = {0, 2, 4, 6};

System.out.println(intArray);

// [I@7637f22

Arrays.toString()

配列の内容を文字列として表現するには、java.util.ArraysのtoString()メソッドを使う。

System.out.println(java.util.Arrays.toString(intArray));
// [0, 2, 4, 6]

1 2	System.out.println(java.util.Arrays.toString(intArray)); // [0, 2, 4, 6]

多次元配列の場合

多次元配列の親配列をtoString()で表示しても下位次元までは適切に表示してくれない。

String[][] twoDimArray = {{"zero", "one", "two"}, {"three", "four", "five"}};

System.out.println(java.util.Arrays.toString(twoDimArray));
// [[Ljava.lang.String;@3830f1c0, [Ljava.lang.String;@39ed3c8d]

String[][] twoDimArray = {{"zero", "one", "two"}, {"three", "four", "five"}};

System.out.println(java.util.Arrays.toString(twoDimArray));

// [[Ljava.lang.String;@3830f1c0, [Ljava.lang.String;@39ed3c8d]

ループによる表示

ループを回して表示させることは考えられる。

for (String[] subarray: twoDimArray) {
  System.out.println(java.util.Arrays.toString(subarray));
}
// [zero, one, two]
// [three, four, five]

for (String[] subarray: twoDimArray) {

System.out.println(java.util.Arrays.toString(subarray));

}

// [zero, one, two]

// [three, four, five]

Arrays.deepToString()

Arrays.deepToString()メソッドを使うと、多次元配列の内容を手軽に表示できる。

String[][] twoDimArray = {{"zero", "one", "two"}, {"three", "four", "five"}};

System.out.println(java.util.Arrays.deepToString(twoDimArray));
// [[zero, one, two], [three, four, five]]

String[][] twoDimArray = {{"zero", "one", "two"}, {"three", "four", "five"}};

System.out.println(java.util.Arrays.deepToString(twoDimArray));

// [[zero, one, two], [three, four, five]]

Java – 配列 – 長さ(サイズ)

2021-06-03 / tau / コメントする

配列の長さ(サイズ)はlengthプロパティーで得られる。Stringの場合のlength()メソッドと異なるので注意。

String[] strArray = {"one", "two", "three", "four"};
System.out.println(strArray.length);
// 4

String[] strArray = {"one", "two", "three", "four"};

System.out.println(strArray.length);

// 4

多次元配列の場合、親の配列の長さは子配列の数になる。

int[][] intArray = {{1, 2, 3}, {4, 5, 6, 7}};

System.out.println(intArray.length);    // 2
System.out.println(intArray[0].length); // 3
System.out.println(intArray[1].length); // 4

int[][] intArray = {{1, 2, 3}, {4, 5, 6, 7}};

System.out.println(intArray.length); // 2

System.out.println(intArray[0].length); // 3

System.out.println(intArray[1].length); // 4