Javaの文法（２）　変数の型指定

型指定

Javaでは、全ての変数を宣言するとき。型の指定をする必要があります。
　　一般形：　型指定子変数 = 値

public class Main {
  public static void main(String[] args) {
    int    整数   = 12;            // ４バイト　約１０桁　整数ではこれが標準
    long   長整数 = 1235689;       // ８バイト　約２０桁
    float  実数   = 12.3f;         // ４バイト有効桁数７　末尾に f を付ける
    double 長実数 = 1.24E8;        // ８バイト有効桁数１４　実数ではこれが標準
    String 文字列 = "あいうえお";  // 任意の文字列
    
    System.out.println("====== 変数の宣言 ========");
    System.out.println("int    整数   = " + 整数);     // 12
    System.out.println("long   長整数 = " + 長整数);   // 1235689
    System.out.println("float  実数   = " + 実数);     // 12.3  fがつかない
    System.out.println("double 長実数 = " + 長実数);   // 1.24E8
    System.out.println("String 文字列 = " + 文字列);   // あいうえお
   
    System.out.println("== 計算での型変換 ==");      // int＜long＜float＜double：型混合算では右側に変換されて計算
    System.out.println("Ａ" + (整数 + 100));           // 112
    System.out.println("Ｂ" + (長整数 + 整数));        // 1235701　整数の型が長整数に合わされる
    System.out.println("Ｃ" + (実数 + 100.04f));       // 112.340004　計算でのリテラルにも f が必要
    System.out.println("Ｄ" + (実数 + 100.04));        // 112.34000019073487　fを付けないと double とみなされる
    System.out.println("Ｅ" + (長実数 / 整数));        // 1.0333333333333334E7　整数が長実数に型変換されつ
    System.out.println("Ｆ" + ("ab" + "cd"));          // abcd
    System.out.println("Ｇ" + ("ab" + 整数));          // ab12　文字と数値では、数値が文字列になる。
  }
}

配列

複数の値を持つ変数には、配列とリストがあります。
Java の配列には大きな制約があります。
　・配列の要素は単一でなければなりません。
　　　　["阿部", "文学部", 20] 　のような配列は定義できません。
　・配列のサイズは事前に指定しておく必要があります。
リストに関しては後述します。

固定長１次元配列

public class Main {
  public static void main(String[] args) {
    int[] 配列Ａ = {10, 11, 12};                              // ア　[ ] ではなく { }
    System.out.println("配列Ａ.length = " + 配列Ａ.length);   // イ　配列Ａ.length = 3
    System.out.println("配列Ａ[0] = " + 配列Ａ[0]);           // ウ　配列Ａ[0] = 10
//  System.out.println("配列Ａ[5] = " + 配列Ａ[5]);           // エ　コンパイルエラー

    int[] 配列Ｂ = new int[3];                                // オ　配列Ａ.length = 3
//  int[] 配列Ｂ = new int[];                                 // カ　コンパイルエラー
    配列Ｂ[0] = 100;                                          // キ　
    配列Ｂ[1] = 110;                                          // ク　配列Ｂ[2]は指定していない
    System.out.println("配列Ｂ.length = " + 配列Ａ.length);   // エ　配列Ｂ.length = 3
    System.out.println("配列Ｂ[2] = " + 配列Ｂ[2]);           // オ　配列Ｂ[2] = 0　undefineではない
    System.out.println("配列Ｂ = " + 配列Ｂ);                 // カ　配列Ｂ = [I@3a71f4dd 意味不明
//  int[] 配列Ｂ = new int[];                                 // キ　コンパイルエラー

//  int[] 配列Ｃ = new int{10, 11, 12};                       // ク　コンパイルエラー [ ] にしてもエラー
 
  }
}

配列の定義には２通りあります。

　　オ：　型指定子[] 配列名 = new 型指定子[サイズ]
　　　　　　　サイズは省略できません（キ）
　　ア：　型指定子[] 配列名 = {要素のリスト}
　　　　　　　[ ] ではなく { } で囲みます。
　　　　　　　リストの個数でサイズが決定します。
　　クのような指定はできません。

型指定子が単一などで、配列の要素はすべて同一でなければなりません。
配列のサイズは、事前に指定する必要があります。
配列のサイズは、配列.length で得られます。イ・エ
　　キ・クでは、配列[2] の定義はしていませんが、配列サイズは 3 になります。
　　未定義の配列[2]は、Undefined ではなく 0 （文字列では　""）になります。
配列のサイズを超えた要素をアクセスしようとすると、コンパイルエラーになります。エ
　　実行時にオーバーフローエラーになるのではありません。
　　しかし、　添字　= 5;　配列[添字]　としたときには、実行時にオーバーフローエラーになります。

固定長２次元配列

public class Main {
  public static void main(String[] args) {
    int[][] 配列Ａ = { { 0,  1,  2},                               // ア
                       {10, 11, 12}
                     };
    System.out.println("配列Ａ.length = " + 配列Ａ.length);        // イ　配列Ａ.length = 2　　 行数
    System.out.println("配列Ａ[0].length = " + 配列Ａ[0].length);  // ウ　配列Ａ[0].length = 3　列数
    System.out.println("配列Ａ[1][2] = " + 配列Ａ[1][2]);          // エ　配列Ａ[1][2] = 12
    System.out.println("配列Ａ[1] = " + 配列Ａ[1]);                // オ　配列Ａ[1] = [I@3a71f4dd
    System.out.println("配列Ａ = " + 配列Ａ);                      // カ　配列Ａ = [[I@85ede7b

    int 行数 = 2;
    int 列数 = 3;
    int[][] 配列Ｂ = new int[行数][列数];                          // キ
    配列Ｂ[1][2] = 12;                                             // ク　個々の要素で指定
//  配列Ｂ[0] = [0, 1, 2};                                         // ケ　コンパイルエラー
    int i = 1;
    int j = 2;
    System.out.println("配列Ｂ[i][j] = " + 配列Ｂ[i][j] );         // コ　配列Ｂ[i][j] = 12
  }
}

配列の定義には２通りあります。
　　キ：　型指定子[][] 配列名 = new 型指定子[行数][列数];
　　ア：　型指定子[][] 配列名 = { {行０要素}, {行１要素}, … };
キのとき、配列に値を与えるには、
　　クのように、個々の要素に指定します。
　　ケのように、行をまとめて指定することはできません。
行数は、配列.length、列数は、配列[0].length （０行の要素の数）で取得できます。
配列全体や行全体を表示できません。オ・カ

リスト　可変長配列

リストは ArrayList で定義され、サイズは事前に指定せず、動的に追加できます。

１次元リスト

import java.util.*;                                              // ア
public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> リストＡ = new ArrayList<Integer>();      // イ
    リストＡ.add(10);                                            // ウ
    リストＡ.add(11);
    リストＡ.add(12);
    System.out.println("リストＡ.size() = " + リストＡ.size());  // エ　リストＡ.size() = 3
    System.out.println("リストＡ.get(0)= " + リストＡ.get(0));   // オ　リストＡ.get(0)= 10
//  System.out.println("リストＡ.get(5)= " + リストＡ.get(5));   // カ　コンパイルエラー

    List<Integer> リストＢ = new ArrayList<Integer> (            // キ
      Arrays.asList(100, 110, 120)
    );
    System.out.println("リストＢ.get(0)= " + リストＢ.get(0));   // ク　リストＢ.get(0)= 100
  }
}

１次元リストの定義には２通りあります。

　　ウ：　List<プリミティブ型> リスト名 = new ArrayList<プリミティブ型>();
            リスト.add(要素) で値をあたえる。
　　キ：　List<プリミティブ型>リスト名 = new ArrayList<プリミティブ型>>(
　　　　　　Arrays.asList(要素[0], 要素[1], ・・・)　←初期値をここで与える
　　　　　);
前と後のプリミティブ型が同じとき（通常）は。後を <> と略記できます。

< > をダイアモンド演算子ともいいます。
ここでは、型指定子とプリミティブ型指定子の違いは省略します。
　　int　　　Integer
　　flort　　Frort
　　Strong 　Strong
Java の標準機能では、ArrayList をサポートしていません。その機能を含むライブラリ java.htil を import しておく必要があります。ア
現在のリストの末尾に新要素を追加するには、リスト名.add(新要素); とします。ウ
リストの長さは lebgth ではなく、size() を用います。エ
リスとの i 番目の要素を参照するには、リスト名[i] ではなく、リスト名.get(i) になります。getは関数ですので、[ ] ではなく ( ) で囲みます。オ

２次元リスト

import java.util.*;
public class Main {
  public static void main(String[] args) {
    ArrayList<ArrayList<Integer>>                                        // ア　２次元リストの定義
      リスト = new ArrayList<ArrayList<Integer>>();
    リスト.add(                                                          // イ　１行の追加
       new ArrayList<Integer>(Arrays.asList(0,1,2))
    );
    リスト.add(
      new ArrayList<Integer>(Arrays.asList(10,11,12))
    );
//  System.out.println("リスト[1][2] = " + リスト[1][2]);                 // ウ　リスト[1][2]　コンパイルエラー 
    System.out.println("リスト.get(1).get(2) = " + リスト.get(1).get(2)); // エ　要素　リスト.get(1).get(2)= 12
    System.out.println("リスト.get(1) = " + リスト.get(1));               // オ　１行　リスト.get(1)= [10, 11, 12]
    System.out.println("リスト = " + リスト);                             // カ　全体　リスト = [[0, 1, 2], [10, 11, 12]]
    System.out.println("リスト.size() = " + リスト.size());               // キ　行数　リスト.size() = 2
//    System.out.println("リスト[0].size() = " + リスト[0].size());       // ク　コンパイルエラー
    System.out.println("リスト.get(0).size() = " + リスト.get(0).size()); // ケ　列数　リスト.get(0).size() = 3
  }
}

ア：２次元リストの定義
１次元リストのときは、ArrayList<Integer> リスト = new ArrayList<Integer>(); でした。ここでの　Integer は「１個の整数型」を示します。
２次元の場合は。この Integer が整数型リストにするのですから。この部分が ArrayList<Integer> になります。
イ：１行の追加
１次元の場合は、リスト.add(要素);　でした。２次元では、要素が１行のリストになります。
１次元リストととして、new ArrayList<Integer>(行リスト) となり、　(Arrays.asList(要素１. 要素２, …))　とします。
ウ・エ（ク・ケ）　要素の参照
配列の要素は　配列{i]{j] で参照しますが、リストでは　リスト.get(1).get(2)　とします。
長さ size() も同様で、クはエラーになり、ケにする必要があります。
オ・カ　リストの参照
このような参照により for ループを節約することができます。

構造体（クラスで代替）

Javaには構造体はありません。それをクラスで代替し実現します。

１次元構造体

class 学生クラス {   // 構造体をクラスとして定義
  String 氏名;    // ┐
  String 学部;    // ├ 構造体の各要素の型指定をする
  int 年齢;       // ┘
}
public class Main {
  public static void main(String[] args) {
    学生クラス 学生 = new 学生クラス();
    学生.氏名 = "阿部";    // ┐
    学生.学部 = "文学部";  // ├ これらの型は学生クラスから引き継がれる
    学生.年齢 = 20;        // ┘
    System.out.println(学生.氏名 + ", " + 学生.学部 + ", " + 学生.年齢);    // 阿部, 文学部, 20
  }
}

２次元構造体

class 学生クラス {
  String 氏名;
  String 学部;
  int 年齢;
};
public class Main {
  public static void main(String[] args) {
    学生クラス[] 学生 = new 学生クラス[2];  // 学生数 = 2
    for (int i=0; i<学生.length; i++) {
      学生[i] = new 学生クラス();           // 各要素ごとにインスタンス化
    };
    学生[0].氏名 = "阿部";
    学生[0].学部 = "文学部";
    学生[0].年齢 = 20; 
    学生[1].氏名 = "井上";
    学生[1].学部 = "工学部";
    学生[1].年齢 = 20;
    for (int i=0; i<学生.length; i++) {
      System.out.println(学生[i].氏名 + ", " + 学生[i].学部 + ", " + 学生[i].年齢);  // 阿部, 文学部, 20
    };                                                                               // 井上, 工学部, 20
  };
}

Javaの文法（２） 変数の型指定

型指定

配列