数字の"1"と数値の1

数字とは一般的に下表のような種類があり、文字列の中（ダブルクォーテーションの中）ではどれも自由に使用可能です。

プロジェクト内のフォルダー名やファイル名、クラス名やメソッド名などのプログラム内で固有名詞として使用される文字（識別子）では、半角アラビア数字のみが、それぞれの命名規則の範囲内で使用可能です。

ローマ数字は大文字も小文字も全角1文字と同じ扱いとなります。アルファベットを組み合わせて代用して表現することは可能ですが、通常のアルファベットとの混乱を招くため避けましょう。

数字を文字列や識別子の一部としてではなく、計算などに使用する数値そのものとして扱いたい場合には、クォーテーションなどで括らずそのまま使用します。

次のサンプルコードを実行すると、正しく計算されるのは4行目の結果のみです。

    static void practiceNumberAndNumeric() {
        Logger.out("1" + "2" + "3" + "4" + "5");
        Logger.out('1' + '2' + '3' + '4' + '5');
        Logger.out(1 + 2 + 3 + 4 + 5);
    }

[2020/12/31 12:34:56.789] 12345 // 文字列の結合
[2020/12/31 12:34:56.789] 255 // 文字コード（'1'は49 ～ '5'は53）の加算
[2020/12/31 12:34:56.789] 15 // 数値の加算

このように「+」記号で式を作っても、それぞれの型に応じた処理が行われ、エラーとなりませんので注意しましょう。

変数に「整数」を代入して使う場合には、変数を「int」型として宣言します。
値は半角アラビア数字で表記し、クォーテーションなどでは括りません。

    static void practiceInt() {
        int intValue = 123;
        Logger.out(intValue);
    }

「int」は英単語の「Integer（インテジャー＝整数）」の略称であるため、イント型・インテジャー型・整数型と呼びます。

整数はマイナスの値も含みますので、次のような計算や代入が可能です。

    static void practiceInt() {
        int intValue = -1;
        Logger.out(intValue);
        intValue = intValue + -2 + -3; // -1 + -2 - 3 = -6 を代入
        Logger.out(intValue);
        intValue = intValue * 30;    // -6 × 30 = -180 を代入
        Logger.out(intValue / -7);   // -180 ÷ -7 = 25
        Logger.out(intValue % -7);   // -180 ÷ -7 = 25 の余りの -5
    }

次のサンプルコードを実行してみましょう。

    static void practiceOverflow() {
        int intValue = 2147483647;
        Logger.out(intValue); // 「2147483647」が出力される
        intValue = intValue + 1;
        Logger.out(intValue); // 「-2147483648」が出力される！
    }

約21億5000万の整数に1を足した途端、マイナスが付いてしまいました。これはオーバーフロー（桁あふれ）と言って、int型の上限値を超過してしまったことが原因です。

int型は内部で「0の次は1、1の次は1繰り上がって10」という2進数32桁でデータを管理しています。また、その先頭の桁は「1ならマイナス、0ならプラス」という符号を表す特殊な桁です。この各桁をビットと呼び、Javaのint型は「符号付き32ビット」である、と言います。

・・・かなり難解ですので、3ビットに単純化した図でこの現象を確認してみましょう。

3桁の「0か1＝ビット」の組み合わせ（8パターン）により、「-4」～「3」を表現している、という図です。ビットが「0,1,1」の状態で1を加算すると、ビットが繰り上がって「1,0,0」になってしまい、ルール上「-4」となってしまう、これがオーバーフローです。

この仮数部の桁が増えるごとに「1の位」「2の位」「4の位」「8」「16」「32」「64」と倍々に増えますので、int型では32ビットで「-2,147,483,648」～「2,147,483,647」という大きな数を管理することができるのです。

int型には「0b」を先頭に付けるとビット列を模した形式で代入することが可能です。普段使うことはまずありえませんが、32ビットの場合の確認用コードを載せておきます。

    static void practiceBit() {
        int bitValue =
            0b00000000000000000000000000000001;
        Logger.out(bitValue); // 1
        bitValue =
            0b00000000000000000000000000000010;
        Logger.out(bitValue); // 2
        bitValue =
            0b00000000000000000000000000000100;
        Logger.out(bitValue); // 4
        bitValue =
            0b00000000000000000000000010000000;
        Logger.out(bitValue); // 128
        bitValue = 
            0b01111111111111111111111111111111;
        Logger.out(bitValue); // 2147483647
        bitValue = bitValue + 
            0b00000000000000000000000000000001;
        Logger.out(bitValue); // -2147483648
        bitValue = 
            0b10000000000000000000000000000000;
        Logger.out(bitValue); // -2147483648
        bitValue = 
            0b11111111111111111111111111111111;
        Logger.out(bitValue); // -1
    }

整数型には管理できるビット数、つまり管理できる数値の範囲が異なる型が存在します。

byte型は画像データの加工処理などにおいて、直接的に「バイナリーデータ（binary data、0か1であるビットの塊）」を操作する際の入れ物、というのが本来の用途ですので、整数としては使用しないでください。8ビットを1バイト（8bit=1byte）と呼ぶことが型名の由来です。

short型は小さな整数を扱う際に、確保するデータ量をなるべく小さくする、ということ目的として使用しますが、通常の用途や現在のコンピューターの構成ではほぼ効果が無く、場合によっては非効率となります。

基本的に整数を扱う場合にはint型を使用し、それで足りなければlong型を使用しましょう。オーバーフローさせていたint型の変数を型のみlong型に変更して、オーバーフローが発生しないことを確認してください。

    static void practiceOverflow() {
        long intValue = 2147483647;
        Logger.out(intValue); // 「2147483647」が出力される
        intValue = intValue + 1;
        Logger.out(intValue); // 「2147483648」が出力される！
    }

なお、int型の範囲外の整数を扱う場合には、数値の末尾に「L」を付与することで、long型であることを明示する必要がありますので注意しましょう。

    static void practiceOverflow() {
        Logger.out(2147483647 + 1);   // オーバーフローにより「-2147483648」
        Logger.out(2147483647L + 1L); // long型となり正しい加算結果となる
        long longValue = 2147483648L; // 「L」を取るとエラー
    }

小文字の「l」も使用可能ですが、「1」との判別が難しい場合があるので避けましょう。

ゲームを作る場合など、longの範囲でもまだ足りないという状況もあります。その場合には、BigIntegerというクラス型を使用しましょう。

詳しい使い方は解説しませんが、longを超える整数どうしの基本的な四則演算と、その結果を見ておきましょう。

※クイックフィックスから「java.math.BigInteger」をインポートしましょう！

    static void practiceBigInteger() {
        BigInteger bigIntValue = BigInteger.valueOf(Long.MAX_VALUE);
        Logger.out(bigIntValue);
        bigIntValue = bigIntValue.add(BigInteger.ONE); // 1加算
        Logger.out(bigIntValue);
        Logger.out(bigIntValue.add(bigIntValue));      // 足し算
        Logger.out(bigIntValue.subtract(bigIntValue)); // 引き算
        Logger.out(bigIntValue.multiply(bigIntValue)); // 掛け算
        Logger.out(bigIntValue.divide(bigIntValue));   // 割り算
    }

[2020/12/31 12:34:56.789] 9223372036854775807    // longの最大値
[2020/12/31 12:34:56.789] 9223372036854775808    // longを超える整数
[2020/12/31 12:34:56.789] 18446744073709551616   // 同値の足し算なので倍
[2020/12/31 12:34:56.789] 0                      // 同値の引き算なので0
[2020/12/31 12:34:56.789] 85070591730234615865843651857942052864  // 巨大！
[2020/12/31 12:34:56.789] 1                      // 同値の割り算なので1