Java – 配列 – 初期化

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

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

全要素が同じ型の配列をイニシャライザーで初期化する書き方。typeはプリミティブ型でも参照型でもよい。

type[] arrayName = {emelent1, emenent2, ...};

import java.util.Arrays;

public class ArrayInit {
  public void initializer() {
    int[] intArray = {0, 2, 4, 6};
    System.out.println(Arrays.toString(intArray));
    // [0, 2, 4, 6]

    String[] stringArray = {"zero", "two", "four", "six"};
    System.out.println(Arrays.toString(stringArray));
    // [zero, two, four, six]
  }

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

import java.util.Arrays;

public class ArrayInit {

public void initializer() {

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

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

// [0, 2, 4, 6]

String[] stringArray = {"zero", "two", "four", "six"};

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

// [zero, two, four, six]

}

public static void main(String[] args) {

ArrayInit app = new ArrayInit();

app.initializer();

}

newによる初期化

newによる配列インスタンスの生成の書き方。typeはプリミティブ型でも参照型でもよい。

type[] arrayName = new type[length];

以下の例では、配列を生成した後に一つずつ要素を定義している。

import java.util.Arrays;

public class ArrayInit {
  public void initByNew() {
    int[] intArray = new int[4];

    intArray[0] = 0;
    intArray[1] = 2;
    intArray[2] = 4;
    intArray[3] = 6;

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

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

import java.util.Arrays;

public class ArrayInit {

public void initByNew() {

int[] intArray = new int[4];

intArray[0] = 0;

intArray[1] = 2;

intArray[2] = 4;

intArray[3] = 6;

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

// [0, 2, 4, 6]

}

public static void main(String[] args) {

ArrayInit app = new ArrayInit();

app.initByNew();

}

newによる初期化直後の値はプリミティブ型ならそれぞれのデフォルト値、参照型ならnullになる。

import java.util.Arrays;

public class ArrayInit {
  public void defaultValues() {
    boolean[] boolArray = new boolean[4];
    System.out.println(Arrays.toString(boolArray));
    // [false, false, false, false]

    int[] intArray = new int[4];
    System.out.println(Arrays.toString(intArray));
    // [0, 2, 4, 6]

    double[] dblArray = new double[4];
    System.out.println(Arrays.toString(dblArray));
    // [0.0, 0.0, 0.0, 0.0]

    char[] charArray = new char[4];
    System.out.println(Arrays.toString(charArray));
    // [, , , ]

    String[] strArray = new String[4];
    System.out.println(Arrays.toString(strArray));
    // [null, null, null, null]

    Object[] objArray = new Object[4];
    System.out.println(Arrays.toString(objArray));
    // [null, null, null, null]
  }

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

import java.util.Arrays;

public class ArrayInit {

public void defaultValues() {

boolean[] boolArray = new boolean[4];

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

// [false, false, false, false]

int[] intArray = new int[4];

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

// [0, 2, 4, 6]

double[] dblArray = new double[4];

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

// [0.0, 0.0, 0.0, 0.0]

char[] charArray = new char[4];

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

// [, , , ]

String[] strArray = new String[4];

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

// [null, null, null, null]

Object[] objArray = new Object[4];

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

// [null, null, null, null]

}

public static void main(String[] args) {

ArrayInit app = new ArrayInit();

app.defaultValues();

}

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

配列宣言時ではなく、宣言済みの配列変数をイニシャライザーで初期化する書き方。

単にイニシャライザーで代入しようとするとエラーになるので、newによる配列の生成とイニシャライザーによる定義を同時に行う。

1つ目のint[]に関してはイニシャライザーによる初期化と同じだが、2つ目のString[]のように一度宣言された変数に対して新たな配列で初期化する場合に有効。

import java.util.Arrays;

public class ArrayInit {
  public void newWithInitializer() {
    int[] intArray = new int[] {0, 1, 2};
    System.out.println(Arrays.toString(intArray));
    // [0, 1, 2]

    String[] strArray = null;
    strArray = new String[] {"A", "B", "C"};
    System.out.println(Arrays.toString(strArray));
    // [A, B, C]
  }

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

import java.util.Arrays;

public class ArrayInit {

public void newWithInitializer() {

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

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

// [0, 1, 2]

String[] strArray = null;

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

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

// [A, B, C]

}

public static void main(String[] args) {

ArrayInit app = new ArrayInit();

app.newWithInitializer();

}

Java – プリミティブ型のリテラル

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

論理型

論理型のリテラルはtrue、falseの2つ。

System.out.println(true);           // true
System.out.println(false);          // false
System.out.println(!true);          // false
System.out.println(!false);         // true
System.out.println(true && false);  // false
System.out.println(true || false);  // true

System.out.println(true); // true

System.out.println(false); // false

System.out.println(!true); // false

System.out.println(!false); // true

System.out.println(true && false); // false

System.out.println(true || false); // true

整数型

int/short/byte

各基数による表現

intの範囲以内の整数は10進、2進、8進、16進で表現可能。

8進表現は頭に’0‘を付ける。以下の表現は8進で表現できない値を指定していることになって、エラーになる。10進や16進表現で要注意。

08、09→範囲外
0a、0bなど→構文エラー

基数	例	範囲
10進	63	-2147483648～2147483647
2進	0b111111	`0b0`～ `0b11111111111111111111111111111111`
8進	077	`00`～`037777777777`？
16進	0x3f	`0x0`～`0ffffffff`

型

整数系のリテラルは、各型で表現できる範囲とビットパターンとの関係で注意が必要。

たとえばbyte型の表現範囲は−128～127で、当然以下のような代入は可能だが、これを超える値は代入できない。

byte b;
b = -128;
b = 127;
b = -129; // コンパイルエラー
b = 128;  // コンパイルエラー

byte b;

b = -128;

b = 127;

b = -129; // コンパイルエラー

b = 128; // コンパイルエラー

一方、2進や16進で表現した場合のリテラルは、型によって解釈の仕方が変わるため、代入結果の値に注意が必要。

たとえば2進数0b1111|1111(16進数0xff)は、byte型なら2の補数表現で−1、short型やint型など9ビット以上を扱えるなら、9ビット目以上が0で埋められて255となる。

short s = 0b11111111; System.out.println(s);      // 255
byte b = (byte)0b11111111; System.out.println(b); // -1

1 2	short s = 0b11111111; System.out.println(s); // 255 byte b = (byte)0b11111111; System.out.println(b); // -1

最上位ビットが8ビット目や16ビット目でそれが1の場合、正数で解釈できる型になり、敢えて補数でマイナス表現としたいときには(byte)などでキャストする必要がある。

符号

各表現に+/-をつけることができて、−をつけると負数になる。

System.out.println(-63);       // -63
System.out.println(-0b111111); // -63
System.out.println(-077);      // -63
System.out.println(-0x3f);     // -63

System.out.println(-63); // -63

System.out.println(-0b111111); // -63

System.out.println(-077); // -63

System.out.println(-0x3f); // -63

各基数による表現を正規表現で表すと以下のような感じか。

10進	`^[+-]?[1-9][0-9]*$`(ただし範囲内)
2進	`^[+-]?0b0*1[01]{0,31}$`
8進	`^[+-]?0+[1-4]?[0-7]{0,10}$`
16進	`^[+-]?0x0*[0-9A-Fa-f]{0,8}$`

long

long型の整数は末尾にl/Lをつける。

int型の範囲内の数でも末尾にLをつけるとlong型になる
int型の範囲を超える数は末尾にLが必須。

System.out.println(1L);           // int以下の範囲でもL/lをつけるとlong型
System.out.println(2147483647);   // intの最大値
System.out.println(2147483648L);  // intの範囲を超える場合はL/lが必要
System.out.println(0xffffffff);   // 2進/16進表記の限界、intでは-1
System.out.println(0xffffffffL);  // long型を明示すると正数の4294967295
System.out.println(0x100000000L); // intの範囲を超える場合はL/lが必要(4294967296)
System.out.println(9223372036854775807L);  // longの最大値(L/lは必須)
// System.out.println(9223372036854775808L);  // longの範囲外は扱えない

System.out.println(1L); // int以下の範囲でもL/lをつけるとlong型

System.out.println(2147483647); // intの最大値

System.out.println(2147483648L); // intの範囲を超える場合はL/lが必要

System.out.println(0xffffffff); // 2進/16進表記の限界、intでは-1

System.out.println(0xffffffffL); // long型を明示すると正数の4294967295

System.out.println(0x100000000L); // intの範囲を超える場合はL/lが必要(4294967296)

System.out.println(9223372036854775807L); // longの最大値(L/lは必須)

// System.out.println(9223372036854775808L); // longの範囲外は扱えない

8進表記の不思議

8進数の場合が不規則。以下の様に2進表記の32ビットを3ビットごとに区切れば8進表示となる。

0b01|11-1|111|-111|1-11|11-1|111|-111|1-11|11-1|111
= 017777777777

0b11|11-1|111|-111|1-11|11-1|111|-111|1-11|11-1|111
= 037777777777

これから、8進表示の整数リテラルの上限は037777777777(10進で−1)となりそうだが、実際には047777777777まで通る。

System.out.println(07777777777);  // 1073741823
System.out.println(017777777777); // 2147483647
System.out.println(020000000000); // -2147483648
System.out.println(020000000001); // -2147483647
System.out.println(037777777777); // -1
System.out.println(040000000000); // 0
System.out.println(040000000001); // 1
System.out.println(047777777777); // 1073741823
// System.out.println(050000000000); // 範囲外エラー

System.out.println(07777777777); // 1073741823

System.out.println(017777777777); // 2147483647

System.out.println(020000000000); // -2147483648

System.out.println(020000000001); // -2147483647

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

System.out.println(040000000000); // 0

System.out.println(040000000001); // 1

System.out.println(047777777777); // 1073741823

// System.out.println(050000000000); // 範囲外エラー

実数型

double/float

Javaの実数型は浮動小数点形式のfloatとdoubleの2つ。

小数点表示をした場合はdoubleとして解釈され、これにfをつけるとfloatで解釈される。

System.out.println(1 / 3);    // 0
System.out.println(1.0 / 3);  // 0.3333333333333333
System.out.println(1.0f / 3); // 0.33333334

System.out.println(1 / 3); // 0

System.out.println(1.0 / 3); // 0.3333333333333333

System.out.println(1.0f / 3); // 0.33333334

小数点と整数部か小数部のいずれかがあれば実数型に解釈される。

System.out.println(1. / 3);   // 0.3333333333333333
System.out.println(.1 / 3);   // 0.03333333333333333
System.out.println(1.f / 3);  // 0.33333334
System.out.println(.1f / 3);  // 0.033333335

System.out.println(1. / 3); // 0.3333333333333333

System.out.println(.1 / 3); // 0.03333333333333333

System.out.println(1.f / 3); // 0.33333334

System.out.println(.1f / 3); // 0.033333335

整数表現にfをつけるとfloat、dをつけるとdoubleに解釈される。

System.out.println(1f / 3);   // 0.33333334
System.out.println(1d / 3);   // 0.3333333333333333

1 2	System.out.println(1f / 3); // 0.33333334 System.out.println(1d / 3); // 0.3333333333333333

文字型

char

文字指定

文字リテラルは、1文字をシングルクォート(')で囲む。全角文字もそのまま。2文字以上はエラー。

System.out.println('K');    // K
System.out.println('あ');   // あ
System.out.println('KLM');  // エラー：文字定数が無効

System.out.println('K'); // K

System.out.println('あ'); // あ

System.out.println('KLM'); // エラー：文字定数が無効

ダブルクォートで囲まれた場合は文字列(String)であり、char型ではない。charはプリミティブ型、Stringは参照型なのでキャストもできない。

System.out.println("M");  // M→Stringとして表示されている
char c = "M";             // 型の不一致: String から char には変換できません

1 2	System.out.println("M"); // M→Stringとして表示されている char c = "M"; // 型の不一致: String から char には変換できません

エスケープ

シングルクォートや改行コード、タブコードなどの特殊文字はエスケープして定義する。

System.out.print('\'');
System.out.print('1');
System.out.print('\t');
System.out.print('2');
System.out.println('\'');
// '1  2'

System.out.print('\'');

System.out.print('1');

System.out.print('\t');

System.out.print('2');

System.out.println('\'');

// '1 2'

ユニコード指定

文字リテラルは、ユニコードのコードポイントでも指定可能。その場合、シングルクォートの中で\uでコードポイントを指定する。

ただしシングルクォートのコードポイント\u0027を指定すると文字定数が無効のエラーになる。ユニコードがコンパイルされたときに'''というリテラルになるためか。

System.out.println('\u004b'); // K
System.out.println('\u3042'); // あ
//  System.out.println('\u0027'); // エラー：文字定数が無効

System.out.println('\u004b'); // K

System.out.println('\u3042'); // あ

// System.out.println('\u0027'); // エラー：文字定数が無効

Java – プリミティブ型

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

論理型

boolean

true/falseの二値。2値を表すのには1ビットで十分だが、実装上の内部表現については明確に定められていないらしい。

リテラル表現はtrue、false
比較式の評価結果は論理値を持つ
他の型へはキャストできない

boolean boolTrue = true;
boolean boolFalse = false;

System.out.println(boolTrue);   // true
System.out.println(boolFalse);  // false

System.out.println(1 == 1);     // true
System.out.println(1 == 0);     // false。

boolean boolTrue = true;

boolean boolFalse = false;

System.out.println(boolTrue); // true

System.out.println(boolFalse); // false

System.out.println(1 == 1); // true

System.out.println(1 == 0); // false。

数値型(整数型)

byte

8ビットの符号付き2進数で表現可能な整数で、範囲は−128～127。内部表現のサイズは1バイト。

byte型で表現可能な最大値127を超えると8ビット目が1となって負数になる
byte型で表現された−1(0b11111111)の演算結果がこれを超える場合、9ビット目以上が無視される
符号なしで8ビット目が1となるリテラル(0b1000000、0x80)以上の数はint型で解釈され、byte型へのキャストが必要
- 8ビット目が1のリテラルをbyte型にキャストした場合、負数とみなされる

byte b = 0;               // 0はそのままbyteとして解釈される
System.out.println(b);    // 0

b = 0b01111111;           // byte型の正数上限
System.out.println(b);    // 127
System.out.println(++b);  // byte型では負数となり-128

b = (byte)0b11111111;     // int型の正数として解釈→キャストが必要
System.out.println(b);    // -1
System.out.println(++b);  // byte型の範囲で循環して0

byte b = 0; // 0はそのままbyteとして解釈される

System.out.println(b); // 0

b = 0b01111111; // byte型の正数上限

System.out.println(b); // 127

System.out.println(++b); // byte型では負数となり-128

b = (byte)0b11111111; // int型の正数として解釈→キャストが必要

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

System.out.println(++b); // byte型の範囲で循環して0

short

16ビットの符号付き2進数で表現可能な整数で、範囲は−32768～32767(約3万)。内部表現のサイズは2バイト。

short型で表現可能な最大値32767を超えると16ビット目が1となって負数になる
short型で表現された−1(0bffff)の演算結果がこれを超える場合、17ビット目以上が無視される
符号なしで16ビット目が1となるリテラル(0x8000)以上の数はint型で解釈され、short型へのキャストが必要
- 16ビット目が1のリテラルをshort型にキャストした場合、負数とみなされる

short s = 0;              // 0はそのままshortとして解釈される
System.out.println(s);    // 0

s = 0x7fff;               // short型の正数上限
System.out.println(s);    // 32767
System.out.println(++s);  // short型では負数となり-32768

s = (short)0xffff;        // int型の正数として解釈→キャストが必要
System.out.println(s);    // -1
System.out.println(++s);  // short型の範囲で循環して0

short s = 0; // 0はそのままshortとして解釈される

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

s = 0x7fff; // short型の正数上限

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

System.out.println(++s); // short型では負数となり-32768

s = (short)0xffff; // int型の正数として解釈→キャストが必要

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

System.out.println(++s); // short型の範囲で循環して0

int

32ビットの符号付き2進数で表現可能な整数で、範囲は−2147483648～2147483647(約21億、10⁹オーダー)。内部表現のサイズは4バイト。

int型で表現可能な最大値2147483647を超えると最上位ビットが1となって負数になる
int型で表現された−1(0bffffffff)の演算結果がこれを超える場合、33ビット目以上が無視される
符号なしで32ビット目が1となるリテラル(0x80000000)以上の数は、そのままint型の負数として解釈される

int i = 0;                // 0はそのままintとして解釈される
System.out.println(i);    // 0

i = 0x7fffffff;           // int型の正数上限
System.out.println(i);    // 2147483647
System.out.println(++i);  // int型では負数となり-2147483648

i = 0xffffffff;            // int型の負数として解釈
System.out.println(i);    // -1
System.out.println(++i);  // int型の範囲で循環して0

int i = 0; // 0はそのままintとして解釈される

System.out.println(i); // 0

i = 0x7fffffff; // int型の正数上限

System.out.println(i); // 2147483647

System.out.println(++i); // int型では負数となり-2147483648

i = 0xffffffff; // int型の負数として解釈

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

System.out.println(++i); // int型の範囲で循環して0

long

64ビットの符号付き2進数で表現可能な整数で、範囲は−9223372036854775808～9223372036854775807(約920京、10¹⁸オーダー)。内部表現のサイズは8バイト。

与えるリテラルが16ビット以内の数値の場合、int型で解釈され、負数の場合は負数として64ビットに拡張される
与えるリテラルが17ビット以上の数値の場合、リテラルには末尾にL/lを付ける必要がある
与えるリテラルが65ビット以上の数値を扱うことはできない
long型で表現可能な最大値9223372036854775807を超えると最上位ビットが1となって負数になる
long型で表現された−1(0bffffffffffffffff)の演算結果がこれを超える場合、65ビット目以上が無視される

long lng = 0xffffffff;      // 16ビット以内の数はint型で解釈
System.out.println(lng);    // -1
System.out.println(Long.toHexString(lng)); // ffffffffffffffff

lng = 0x100000000L;          // 17ビット以上の数は末尾にL/lをつけないと範囲外エラー
System.out.println(lng);    // 4294967296

lng = 0x7fffffffffffffffL;  // long型の正数上限
System.out.println(lng);    // 9223372036854775807
System.out.println(++lng);  // long型で負数となり-9223372036854775808

lng = 0xffffffffffffffffL;  // long型の負数として解釈
System.out.println(lng);    // -1
System.out.println(++lng);  // long型の範囲で循環して0

// lng = 0x10000000000000000L;
// 65ビット以上の整数は扱えない

long lng = 0xffffffff; // 16ビット以内の数はint型で解釈

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

System.out.println(Long.toHexString(lng)); // ffffffffffffffff

lng = 0x100000000L; // 17ビット以上の数は末尾にL/lをつけないと範囲外エラー

System.out.println(lng); // 4294967296

lng = 0x7fffffffffffffffL; // long型の正数上限

System.out.println(lng); // 9223372036854775807

System.out.println(++lng); // long型で負数となり-9223372036854775808

lng = 0xffffffffffffffffL; // long型の負数として解釈

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

System.out.println(++lng); // long型の範囲で循環して0

// lng = 0x10000000000000000L;

// 65ビット以上の整数は扱えない

数値型(実数型)

float

32ビット(4バイト)の浮動小数点数で、−3.4028235×10³⁸～−1.4×10⁻⁴⁵、1.4×10⁻⁴⁵～3.4028235×10³⁸の範囲の実数を扱える。

内部表現はIEEE754、符号1ビット、指数部8ビット、仮数部23ビット
最大値はFloat.MAX、最小値はFloat.MINで取得できる
最大値を超える値はInfinity、絶対値が最小値を下回る値は0.0となる

double

64 ビット(8バイト)の浮動小数点数で、−1.7976931348623157×10³⁰⁸～−4.9×10⁻³²⁴、4.9×10⁻³²⁴～1.7976931348623157×10³⁰⁸の範囲の実数を扱える。

内部表現はIEEE754、符号1ビット、指数部11ビット、仮数部52ビット
最大値はDouble.MAX、最小値はDouble.MINで取得できる
最大値を超える値はInfinity、絶対値が最小値を下回る値は0.0となる

文字型

char

16ビットのユニコード1文字を扱う。シングルクォートで囲んだ1文字のほか、ユニコードなら\u0000～\uffff、10進数なら0～65535。

    for (char c = '!'; c <= '~'; c++) {
      System.out.print(c);
    }
    // !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

    System.out.println();
    for (char c = 0x0021; c <= 0x007e; c++) {
      System.out.print(c);
    }
    // !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

    System.out.println();
    for (char c = 'ぁ'; c <= 'ん'; c++) {
      System.out.print(c);
    }
    // ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわゐゑをん

    System.out.println();
    for (char c = 0x3041; c <= 0x03093; c++) {
      System.out.print(c);
    }
    // ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわゐゑをん

    System.out.println();

for (char c = '!'; c <= '~'; c++) {

System.out.print(c);

}

// !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

System.out.println();

for (char c = 0x0021; c <= 0x007e; c++) {

System.out.print(c);

}

// !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

System.out.println();

for (char c = 'ぁ'; c <= 'ん'; c++) {

System.out.print(c);

}

// ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわゐゑをん

System.out.println();

for (char c = 0x3041; c <= 0x03093; c++) {

System.out.print(c);

}

System.out.println();

TauStation

タグ: Java

Java – 配列 – 初期化

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

newによる初期化

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

Java – プリミティブ型のリテラル

論理型

整数型

int/short/byte

各基数による表現

型

符号

long

8進表記の不思議

実数型

double/float

文字型

char

文字指定

エスケープ

ユニコード指定

Java – プリミティブ型

論理型

boolean

数値型(整数型)

byte

short

int

long

数値型(実数型)

float

double

文字型

char