Javaでlong型を理解！使い方と詳細ガイド10選

はじめに
●Javaのlong型とは
- ○long型の基本
- ○long型のメリットとデメリット
  - □メリット
  - □デメリット
●long型の詳しい使い方
●long型の応用例
●注意点と対処法
- ○long型の上限と下限
- ○オーバーフローのリスクと対策
●カスタマイズ方法
- ○long型のフォーマット表示
- ○ユーザー定義のメソッドとlong型
まとめ

はじめに

この記事を読めば、Javaのlong型の使い方をマスターすることができるようになります。

プログラミング言語Javaにおいて、数値を扱う際に避けては通れないのが、数値型の一つであるlong型です。

ただ、初心者にとっては「int型と何が違うの？」、「どう使うの？」といった疑問が多いもの。

そこで今回は、long型の基本から応用、注意点に至るまでを徹底的に解説します。

具体的なサンプルコードを交えながら、一緒に学んでいきましょう。

●Javaのlong型とは

○long型の基本

long型は、Javaで64ビット整数値を表すためのデータ型です。

具体的には、-9,223,372,036,854,775,808から9,223,372,036,854,775,807までの範囲の整数を扱えます。

long型は主に次のように宣言されます。

// long型変数の宣言
long myVar = 1000L;

このコードでは、myVarという名前のlong型変数を宣言し、1000を代入しています。

long型のリテラルには、末尾にLまたはl（大文字のエルまたは小文字のエル）を付けるのが一般的です。

このサンプルコードを実行すると、myVar変数には1000という値が格納されます。

○long型のメリットとデメリット

long型には、特有のメリットとデメリットがあります。

□メリット

大きな数値を扱える：int型よりも広い範囲の整数値を扱うことができます。
互換性：long型は多くのライブラリやフレームワークで広く使われています。

□デメリット

メモリ消費：long型は64ビットのメモリ領域を使うため、int型（32ビット）よりも多くのメモリを消費します。
計算速度：場合によっては、int型よりも計算速度が遅くなる可能性があります。

このように、long型はその特性から多くの場面で使われていますが、一方でデメリットも存在します。

そのため、用途に応じて適切な数値型を選ぶ必要があります。

●long型の詳しい使い方

long型には多くの使い方がありますが、最も一般的な使い方をいくつか挙げていきます。

○サンプルコード1：基本的なlong型変数の宣言と初期化

最も基本的なlong型変数の宣言と初期化方法を紹介します。

// long型変数の宣言
long num1;

// 初期化
num1 = 3000000000L;

// 宣言と同時に初期化
long num2 = 4000000000L;

このコードでは、num1という名前のlong型変数を宣言し、3000000000を代入しています。

また、num2という名前のlong型変数を宣言と同時に4000000000で初期化しています。

このようにして、long型変数を簡単に使うことができます。

このサンプルコードの実行後、変数num1には3000000000、num2には4000000000がそれぞれ格納される形になります。

○サンプルコード2：long型での算術演算

long型変数を使った基本的な算術演算について見てみましょう。

long a = 5000000000L;
long b = 2000000000L;

// 加算
long sum = a + b;

// 減算
long diff = a - b;

// 乗算
long product = a * b;

// 除算
long quotient = a / b;

このコードは、加算、減算、乗算、除算の基本的な操作を表しています。

aとbはそれぞれ5000000000と2000000000で初期化され、それらを使って各種算術演算を行っています。

このサンプルコードを実行すると、変数sumには7000000000、diffには3000000000、productには10000000000000000000、quotientには2が格納されます。

○サンプルコード3：long型と他の数値型との変換

long型と他の数値型（例えば、int型やfloat型）との間で変換が必要な場面もあります。

long longVal = 1000000000L;

// longからintに変換
int intVal = (int) longVal;

// longからfloatに変換
float floatVal = (float) longVal;

// longからdoubleに変換
double doubleVal = (double) longVal;

このコードでは、long型のlongValを他の数値型に変換しています。

long型からint型、float型、double型に変換する際は、キャスト演算子を用いる方法が一般的です。

このコードを実行すると、変数intValには1000000000、floatValには1000000000.0、doubleValには1000000000.0という値が格納されます。

●long型の応用例

基本的な使い方に慣れたら、次はlong型を更に活用してみましょう。

より実践的な例をいくつかご紹介します。

○サンプルコード4：long型を使用した計算処理

long型は大きな数値を扱う場合に非常に便利です。

long型を使用してファクトリアル（階乗）を計算するJavaのプログラムを紹介します。

// long型を使用して階乗を計算するプログラム
public class LongFactorial {
    public static void main(String[] args) {
        long n = 20;
        long factorial = 1;

        for(long i = 1; i <= n; i++) {
            factorial *= i;
        }

        System.out.println("20の階乗は " + factorial + " です。");
    }
}

このコードでは、1から20までの数値を順番に掛け合わせて、20の階乗を計算しています。

階乗の計算にはforループを用い、計算結果をlong型の変数factorialに格納しています。

このプログラムを実行すると、”20の階乗は 2432902008176640000 です。”という出力が得られます。

○サンプルコード5：long型の配列の操作

long型の配列も便利な場合が多く、例えば大きな数値の一覧を効率よく管理したいときなどに使います。

long型の配列を生成し、その要素に値を代入するサンプルコードを紹介します。

// long型の配列を操作するプログラム
public class LongArrayExample {
    public static void main(String[] args) {
        // long型の配列を宣言と同時に初期化
        long[] numbers = new long[]{10000000000L, 20000000000L, 30000000000L};

        // 配列の各要素に1を加算
        for(int i = 0; i < numbers.length; i++) {
            numbers[i]++;
        }

        // 配列の各要素を出力
        for(long num : numbers) {
            System.out.println("配列の要素: " + num);
        }
    }
}

このサンプルコードでは、配列numbersに大きな数値を3つ格納しています。

その後、forループを使用して各要素に1を加算し、加算後の値を出力しています。

プログラムを実行すると、出力として「配列の要素: 10000000001」、「配列の要素: 20000000001」、「配列の要素: 30000000001」と表示されます。

○サンプルコード6：long型とストリームAPIの組み合わせ

Java 8以降、ストリームAPIはデータの集合を効率的に処理するためによく使用されます。

long型の配列やリストなどと組み合わせることで、特に大量の数値データに対する操作が一層効率的に行えます。

long型の配列とストリームAPIを使用して平均値を求めるJavaのサンプルコードを紹介します。

import java.util.Arrays;
import java.util.OptionalDouble;

public class LongWithStream {
    public static void main(String[] args) {
        // long型の配列を宣言
        long[] numbers = {10L, 20L, 30L, 40L, 50L};

        // ストリームAPIを使用して平均値を求める
        OptionalDouble average = Arrays.stream(numbers).average();

        // 平均値が存在するか確認してから出力
        if (average.isPresent()) {
            System.out.println("平均値は " + average.getAsDouble() + " です。");
        } else {
            System.out.println("計算できませんでした。");
        }
    }
}

このコードでは、Arrays.stream()メソッドでlong型の配列をストリームに変換しています。

その後、average()メソッドで平均値を求め、OptionalDouble型で結果を受け取っています。

このように、ストリームAPIを使うことで一連の操作を簡潔かつ効率的に行えます。

このコードを実行すると、出力結果として「平均値は 30.0 です。」が表示されます。

○サンプルコード7：long型を用いた日付・時刻の計算

Javaでは、日付や時刻の計算には通常java.timeパッケージが用いられますが、時にはlong型でミリ秒単位での計算が必要な場合もあります。

long型を用いて2つの日時の差（ミリ秒）を計算するプログラムを紹介します。

public class LongForTimeDifference {
    public static void main(String[] args) throws InterruptedException {
        // 現在の時刻（ミリ秒）を取得
        long startTime = System.currentTimeMillis();

        // 何らかの処理（ここではスリープで模倣）
        Thread.sleep(2000);

        // 処理後の時刻（ミリ秒）を取得
        long endTime = System.currentTimeMillis();

        // 2つの時刻の差（ミリ秒）を計算
        long difference = endTime - startTime;

        System.out.println("処理にかかった時間は " + difference + " ミリ秒です。");
    }
}

このプログラムでは、System.currentTimeMillis()メソッドを用いて現在時刻（ミリ秒単位）を取得し、その後何らかの処理（この例では2秒のスリープ）を行った後に再度現在時刻を取得します。

そして、2つの時刻（ミリ秒）の差をlong型の変数で計算しています。

このプログラムを実行すると、出力結果は「処理にかかった時間は 2000 ミリ秒です。」（若干の誤差があるかもしれませんが）となります。

○サンプルコード8：long型の大きな値の扱い方

Javaで数値を扱う際、long型は非常に大きな整数値を格納することが可能です。

そのため、特に大きな数値計算やデータ処理において、この型の利用は欠かせません。

しかし、大きな数値を扱う際には注意が必要です。

まず、long型の数値リテラルには、末尾に「L」をつけることを忘れないようにしましょう。

これを省略すると、コンパイラはその数値をint型として解釈しようとします。

public class LongExample {
    public static void main(String[] args) {
        // 正しいlong型のリテラル
        long correctValue = 9223372036854775807L;

        // エラーとなるリテラル（「L」を忘れるとint型として解釈される）
        // long errorValue = 9223372036854775807;  // この行はコメントアウトしてあります

        System.out.println("正しいlong型の値: " + correctValue);
    }
}

このコードでは、correctValueという変数にlong型の最大値を代入しています。

末尾の「L」が重要で、これを忘れるとエラーとなるので、コメントアウトして示しています。

上記のコードを実行すると、「正しいlong型の値: 9223372036854775807」という結果が得られます。

また、long型の値を扱う際には、計算途中でオーバーフローやアンダーフローが起きる可能性も考慮する必要があります。

これにより、意図しない計算結果を返す恐れがあります。

○サンプルコード9：long型のビット演算

ビット演算は、数値のビット単位での操作を行うものです。

long型の変数もビット演算の対象として扱うことができます。

long型の変数にビット演算を行うサンプルコードを紹介します。

public class LongBitOperation {
    public static void main(String[] args) {
        long value1 = 60L;  // 0011 1100 
        long value2 = 13L;  // 0000 1101

        // ビットAND演算
        long result1 = value1 & value2;  // 0000 1100 -> 12
        System.out.println("ビットANDの結果: " + result1);

        // ビットOR演算
        long result2 = value1 | value2;  // 0011 1101 -> 61
        System.out.println("ビットORの結果: " + result2);
    }
}

このコードでは、value1とvalue2という2つのlong型の変数にビット演算を適用しています。

まず、&演算子を使用してビットAND演算を行い、その後|演算子を使用してビットOR演算を行っています。

このコードを実行すると、ビットANDの結果は12となり、ビットORの結果は61となります。

○サンプルコード10：long型とラッパークラスの活用

Javaのlong型といえば、主にプリミティブ型として認識されがちですが、そのオブジェクト表現も存在します。

このオブジェクト表現が「ラッパークラス」と呼ばれるものです。

ラッパークラスは、プリミティブ型のデータをオブジェクトとして扱いたい場合や、null値の使用が必要な場面で活用されます。

public class LongWrapperExample {
    public static void main(String[] args) {
        // プリミティブ型longからラッパークラスLongへの変換
        long primitiveLong = 42L;
        Long wrappedLong = Long.valueOf(primitiveLong); // プリミティブ型から変換
        System.out.println("ラッパークラスLongの値: " + wrappedLong);

        // ラッパークラスLongからプリミティブ型longへの変換
        long unwrappedLong = wrappedLong.longValue(); // ラッパークラスから変換
        System.out.println("プリミティブ型longの値: " + unwrappedLong);
    }
}

このサンプルコードでは、プリミティブ型のlongとそのラッパークラスLongを相互に変換しています。

Long.valueOf()メソッドは、プリミティブ型のlongからLongオブジェクトへ変換します。

また、Long.longValue()メソッドは、Longオブジェクトからプリミティブ型のlongへ変換します。

このコードを実行すると、最初に「ラッパークラスLongの値: 42」と出力され、次に「プリミティブ型longの値: 42」と出力されます。

このように、変換が正しく行われていることが確認できます。

ラッパークラスは、Javaのコレクションフレームワーク（ArrayListやHashMapなど）でプリミティブ型を扱う場合や、プリミティブ型に対してnull値を設定したい場合にも有用です。

また、Longクラスにはlong型に特有の各種便利メソッドも用意されています。

例えば、下記のコードではLongクラスのcompareメソッドを使って2つのlong型の数値を比較しています。

public class LongCompareExample {
    public static void main(String[] args) {
        long value1 = 42L;
        long value2 = 73L;
        int result = Long.compare(value1, value2);
        System.out.println("比較結果: " + result);
    }
}

このコードでは、Long.compare()メソッドを使用してvalue1とvalue2を比較します。

Long.compare()メソッドは、第一引数が第二引数より小さい場合は-1、等しい場合は0、大きい場合は1を返します。

このコードの実行結果は、「比較結果: -1」になります。

このようにvalue1がvalue2よりも小さいため、期待通り-1が出力されます。

●注意点と対処法

long型は多くの場面で活用されますが、いくつかの注意点が存在します。

これらの注意点を理解し、適切に対処することで、より安全かつ効率的なコーディングが可能になります。

○long型の上限と下限

long型は64ビットの整数型であり、その値域は-9,223,372,036,854,775,808から9,223,372,036,854,775,807までです。

この範囲を超えた数値を扱おうとすると、問題が発生します。

public class LongLimitExample {
    public static void main(String[] args) {
        // long型の最大値と最小値を出力
        System.out.println("long型の最大値: " + Long.MAX_VALUE);
        System.out.println("long型の最小値: " + Long.MIN_VALUE);
    }
}

このコードは、Javaが提供しているLong.MAX_VALUEとLong.MIN_VALUEを用いて、long型の最大値と最小値を出力します。

コードを実行すると、「long型の最大値: 9223372036854775807」と「long型の最小値: -9223372036854775808」という結果が出力されるため、この範囲内で数値を扱う必要があります。

○オーバーフローのリスクと対策

long型の値域を超える計算を行うと、オーバーフローが発生します。

オーバーフローとは、数値がその型で扱える範囲を超えた場合に発生する現象です。

public class LongOverflowExample {
    public static void main(String[] args) {
        long maxLong = Long.MAX_VALUE; // long型の最大値を取得
        System.out.println("最大値を超える前: " + maxLong);

        // 最大値に1を足してオーバーフローを発生させる
        maxLong += 1;
        System.out.println("最大値を超えた後: " + maxLong); 
    }
}

このコードでは、long型の最大値に1を足すことでオーバーフローを発生させています。

このコードを実行すると、「最大値を超える前: 9223372036854775807」に続いて、「最大値を超えた後: -9223372036854775808」と表示されます。

最大値を超えた結果、最小値になってしまうのがオーバーフローです。

オーバーフローの対処法としては、計算前に値域をチェックするか、数値演算ライブラリを使用する方法があります。

Java 8以降では、Math.addExact()、Math.subtractExact()などのメソッドが用意されており、オーバーフローが発生する場合は例外を投げてくれます。

public class OverflowPreventionExample {
    public static void main(String[] args) {
        try {
            long result = Math.addExact(Long.MAX_VALUE, 1);
            System.out.println("計算結果: " + result);
        } catch (ArithmeticException e) {
            System.out.println("オーバーフローが発生しました。");
        }
    }
}

このコードを実行すると、「オーバーフローが発生しました。」と表示され、計算が途中で停止することなく、例外処理が適切に行われます。

●カスタマイズ方法

long型を使う際には、表示方法や計算処理をカスタマイズすることがしばしばあります。

ここでは、long型のフォーマット表示やユーザー定義メソッドとの連携方法について具体的なコード例とともに解説します。

○long型のフォーマット表示

long型の数値を特定の形式で表示するためには、String.formatメソッドやSystem.out.printfメソッドが使用できます。

これによって、数値をコンマ区切りや特定の桁数で表示するといったカスタマイズが可能です。

public class LongFormatExample {
    public static void main(String[] args) {
        long number = 1234567890L;
        // コンマ区切りで表示
        String formattedNumber = String.format("%,d", number);
        System.out.println("コンマ区切りでの表示: " + formattedNumber);
    }
}

このコードはString.formatメソッドを用いて、long型の数値をコンマ区切りにして表示しています。

このコードを実行すると、コンマ区切りでの表示: 1,234,567,890と出力されます。

○ユーザー定義のメソッドとlong型

Javaでは、ユーザーが独自にメソッドを定義することで、long型の値をさまざまな形で操作することができます。

独自の計算ルーチンや変換処理を作成する際にはこのような手法が有用です。

public class LongCustomMethodExample {
    public static void main(String[] args) {
        long value = 5L;
        // ユーザー定義メソッドで2乗を計算
        long squaredValue = calculateSquare(value);
        System.out.println(value + "の2乗は" + squaredValue + "です。");
    }

    // long型の数値を2乗するユーザー定義メソッド
    public static long calculateSquare(long x) {
        return x * x;
    }
}

このサンプルコードでは、calculateSquareというユーザー定義メソッドを作成し、その中でlong型の数値を2乗しています。

mainメソッドでこのcalculateSquareメソッドを呼び出し、計算結果を出力しています。

このコードを実行すると、5の2乗は25です。と表示されます。