[Java] ByteBufferの使い方をわかりやすく解説

ByteBufferは、JavaのNIO(New Input/Output)パッケージで提供されるバッファの一種で、主にバイナリデータの読み書きに使用されます。

ByteBufferは、allocate(int capacity)で指定した容量のバッファを作成し、put()でデータを書き込み、get()でデータを読み取ります。

flip()を呼び出すことで、書き込みモードから読み取りモードに切り替えます。

clear()でバッファをリセットし、再利用可能にします。

この記事でわかること

ByteBufferの基本操作と使い方
ヒープバッファとダイレクトバッファの違い
ByteBufferの高度な操作方法
ネットワーク通信での活用法
パフォーマンス最適化のポイント

目次から探す

ByteBufferとは

ByteBufferは、Java NIO(New Input/Output)パッケージに含まれるクラスで、バイナリデータを効率的に扱うためのバッファです。

主に、データの読み書きや変換を行う際に使用されます。

ByteBufferは、メモリ内のデータを直接操作できるため、高速なI/O処理が可能です。

特に、ファイルやネットワーク通信などの場面で、データのバッファリングやエンコーディング、デコーディングに役立ちます。

また、ByteBufferは、ヒープバッファとダイレクトバッファの2種類があり、それぞれ異なる特性を持っています。

これにより、用途に応じた最適なバッファの選択が可能です。

ByteBufferの基本操作

ByteBufferの生成方法

ByteBufferを生成するには、allocateメソッドを使用します。

このメソッドは、指定したサイズのヒープバッファを作成します。

また、ByteBuffer.allocateDirectメソッドを使用すると、ダイレクトバッファを生成できます。

以下は、ヒープバッファとダイレクトバッファの生成例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        // ヒープバッファの生成
        ByteBuffer heapBuffer = ByteBuffer.allocate(10);
        
        // ダイレクトバッファの生成
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(10);
        
        System.out.println("ヒープバッファとダイレクトバッファを生成しました。");
    }
}

ヒープバッファとダイレクトバッファを生成しました。

データの書き込み (putメソッド)

putメソッドを使用すると、ByteBufferにデータを書き込むことができます。

以下の例では、整数値をバッファに書き込んでいます。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        
        // データの書き込み
        buffer.put((byte) 10); // 1バイトのデータ
        buffer.putInt(100);     // 4バイトの整数データ
        
        System.out.println("データを書き込みました。");
    }
}

データを書き込みました。

データの読み込み (getメソッド)

getメソッドを使用すると、ByteBufferからデータを読み込むことができます。

以下の例では、先ほど書き込んだデータを読み込んでいます。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put((byte) 10);
        buffer.putInt(100);
        
        // バッファの読み込み位置をリセット
        buffer.flip();
        
        // データの読み込み
        byte byteValue = buffer.get(); // 1バイトのデータを読み込む
        int intValue = buffer.getInt(); // 4バイトの整数データを読み込む
        
        System.out.println("読み込んだデータ: " + byteValue + ", " + intValue);
    }
}

読み込んだデータ: 10, 100

flipメソッドの役割

flipメソッドは、書き込みモードから読み込みモードに切り替えるために使用されます。

このメソッドを呼び出すと、現在の位置がリセットされ、バッファの制限が現在の位置に設定されます。

これにより、書き込んだデータを正しく読み込むことができます。

clearとrewindの違い

clearメソッドは、バッファをクリアし、書き込み位置を先頭に戻します。

バッファ内のデータはそのまま残りますが、読み込み位置はリセットされます。

rewindメソッドは、読み込み位置を先頭に戻しますが、書き込み位置はそのままです。

データを再度読み込む際に便利です。

markとresetの使い方

markメソッドは、現在の位置を記録します。

これにより、後でその位置に戻ることができます。

resetメソッドは、markで記録した位置に戻ります。

これを使用することで、特定の位置からデータを再度読み込むことが可能です。

以下は、markとresetの使用例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put((byte) 10);
        buffer.put((byte) 20);
        
        buffer.flip();
        
        // 現在の位置をマーク
        buffer.mark();
        
        // データを読み込む
        byte firstValue = buffer.get();
        
        // マークした位置に戻る
        buffer.reset();
        
        // 再度データを読み込む
        byte secondValue = buffer.get();
        
        System.out.println("最初の値: " + firstValue + ", 2回目の値: " + secondValue);
    }
}

最初の値: 10, 2回目の値: 10

ByteBufferの種類

ヒープバッファとダイレクトバッファの違い

ByteBufferには、主にヒープバッファとダイレクトバッファの2種類があります。

以下の表にそれぞれの特徴をまとめました。

スクロールできます

特徴	ヒープバッファ	ダイレクトバッファ
メモリの場所	JVMのヒープ領域	OSのネイティブメモリ
アクセス速度	比較的遅い	高速
ガベージコレクション	GCの影響を受ける	GCの影響を受けない
使用方法	`ByteBuffer.allocate`で生成	`ByteBuffer.allocateDirect`で生成

ヒープバッファの特徴と使い方

ヒープバッファは、JVMのヒープ領域にメモリを確保します。

ガベージコレクションの影響を受けるため、メモリ管理が自動で行われますが、アクセス速度はダイレクトバッファに比べて遅くなります。

ヒープバッファは、一般的なデータ処理や小規模なアプリケーションでの使用に適しています。

以下は、ヒープバッファの生成と使用例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        // ヒープバッファの生成
        ByteBuffer heapBuffer = ByteBuffer.allocate(10);
        
        // データの書き込み
        heapBuffer.put((byte) 1);
        heapBuffer.put((byte) 2);
        
        // バッファの読み込み位置をリセット
        heapBuffer.flip();
        
        // データの読み込み
        System.out.println("ヒープバッファのデータ: " + heapBuffer.get() + ", " + heapBuffer.get());
    }
}

ヒープバッファのデータ: 1, 2

ダイレクトバッファの特徴と使い方

ダイレクトバッファは、OSのネイティブメモリに直接メモリを確保します。

これにより、I/O操作が高速化され、特に大規模なデータ処理やネットワーク通信において効果を発揮します。

ダイレクトバッファは、ガベージコレクションの影響を受けないため、長時間使用する場合に適しています。

以下は、ダイレクトバッファの生成と使用例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        // ダイレクトバッファの生成
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(10);
        
        // データの書き込み
        directBuffer.put((byte) 3);
        directBuffer.put((byte) 4);
        
        // バッファの読み込み位置をリセット
        directBuffer.flip();
        
        // データの読み込み
        System.out.println("ダイレクトバッファのデータ: " + directBuffer.get() + ", " + directBuffer.get());
    }
}

ダイレクトバッファのデータ: 3, 4

どちらを選ぶべきか？

ヒープバッファとダイレクトバッファの選択は、アプリケーションの要件によります。

以下のポイントを考慮して選択してください。

パフォーマンスが重要な場合: ネットワーク通信や大規模なデータ処理を行う場合は、ダイレクトバッファを選ぶと良いでしょう。
メモリ管理が簡単な方が良い場合: 小規模なアプリケーションや、ガベージコレクションの影響を気にしない場合は、ヒープバッファが適しています。
メモリ使用量: ダイレクトバッファは、OSのネイティブメモリを使用するため、メモリの使用量に注意が必要です。

ヒープバッファは、JVMのヒープ領域を使用するため、メモリ管理が容易です。

ByteBufferの高度な操作

compactメソッドの使い方

compactメソッドは、ByteBufferの読み込み位置から現在の位置までのデータを前方に移動し、残りの空き領域を利用できるようにします。

このメソッドを使用することで、読み込んだデータを再利用する際に便利です。

以下は、compactメソッドの使用例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        
        // データの書き込み
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        
        // バッファの読み込み位置をリセット
        buffer.flip();
        
        // データの読み込み
        System.out.println("読み込んだデータ: " + buffer.get());
        
        // compactメソッドを呼び出す
        buffer.compact();
        
        // 新しいデータの書き込み
        buffer.put((byte) 3);
        
        // バッファの読み込み位置をリセット
        buffer.flip();
        
        // 残りのデータを読み込む
        System.out.println("残りのデータ: " + buffer.get());
    }
}

読み込んだデータ: 1
残りのデータ: 2

sliceメソッドで部分バッファを作成

sliceメソッドは、元のByteBufferから部分的なバッファを作成します。

この部分バッファは、元のバッファと同じメモリを共有しているため、元のバッファの変更が部分バッファにも影響します。

以下は、sliceメソッドの使用例です。

import java.nio.ByteBuffer;

public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // データの書き込み
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);

        // バッファの読み込み位置をリセット
        buffer.flip();

        // 部分バッファを作成
        ByteBuffer slicedBuffer = buffer.slice();

        // 部分バッファにデータを書き込む
        // ここでの書き込みは元のバッファのデータを上書きするので注意
        slicedBuffer.put((byte) 4);

        // 元のバッファのデータを読み込む
        System.out.println("元のバッファのデータ: " + buffer.get() + ", " + buffer.get() + ", " + buffer.get());
    }
}

元のバッファのデータ: 4, 2, 3

duplicateメソッドでバッファを複製

duplicateメソッドは、元のByteBufferの状態を保持したまま、新しいバッファを作成します。

この新しいバッファは、元のバッファと同じメモリを共有しますが、独立した読み込み位置と書き込み位置を持ちます。

以下は、duplicateメソッドの使用例です。

import java.nio.ByteBuffer;

public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // データの書き込み
        buffer.put((byte) 1);
        buffer.put((byte) 2);

        // バッファの読み込み位置をリセット
        buffer.flip();

        // バッファを複製
        ByteBuffer duplicatedBuffer = buffer.duplicate();

        // 複製したバッファからデータを読み込む
        System.out.println("複製したバッファのデータ: " + duplicatedBuffer.get());

        // 元のバッファからもデータを読み込む
        System.out.println("元のバッファのデータ: " + buffer.get());
    }
}

複製したバッファのデータ: 1
元のバッファのデータ: 1

orderメソッドでエンディアンを指定

orderメソッドを使用すると、バッファ内のデータのエンディアン(バイトオーダー)を指定できます。

デフォルトでは、バッファはビッグエンディアンですが、リトルエンディアンに変更することも可能です。

以下は、orderメソッドの使用例です。

import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(4);

        // ビッグエンディアンで整数を書き込む
        buffer.putInt(1);

        // バッファの読み込み位置をリセット
        buffer.flip();

        // ビッグエンディアンで読み込む
        System.out.println("ビッグエンディアン: " + buffer.getInt());

        // バッファをクリアして再利用
        buffer.clear();

        // リトルエンディアンに変更
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // リトルエンディアンで整数を書き込む
        buffer.putInt(1);

        // バッファの読み込み位置をリセット
        buffer.flip();

        // リトルエンディアンで読み込む
        System.out.println("リトルエンディアン: " + buffer.getInt());
    }
}

ビッグエンディアン: 1
リトルエンディアン: 1

asReadOnlyBufferで読み取り専用バッファを作成

asReadOnlyBufferメソッドを使用すると、元のByteBufferの読み取り専用バージョンを作成できます。

このバッファは、データの読み込みは可能ですが、書き込みはできません。

以下は、asReadOnlyBufferメソッドの使用例です。

import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        
        // データの書き込み
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        
        // 読み取り専用バッファを作成
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
        
        // 読み取り専用バッファからデータを読み込む
        readOnlyBuffer.flip();
        System.out.println("読み取り専用バッファのデータ: " + readOnlyBuffer.get());
        
        // 書き込みを試みると例外が発生する
        try {
            readOnlyBuffer.put((byte) 3);
        } catch (UnsupportedOperationException e) {
            System.out.println("書き込みはできません: " + e.getMessage());
        }
    }
}

読み取り専用バッファのデータ: 1
書き込みはできません: null

ByteBufferと他のBufferの違い

Java NIOには、ByteBufferの他にもさまざまなバッファクラスが用意されています。

ここでは、CharBuffer、IntBuffer、FloatBufferとの違いを説明し、それぞれの使い分けについても触れます。

CharBufferとの違い

CharBufferは、文字データを扱うためのバッファです。

ByteBufferがバイナリデータを扱うのに対し、CharBufferはUTF-16エンコーディングで文字を格納します。

CharBufferは、文字列の処理やテキストデータの読み書きに適しています。

以下は、CharBufferの使用例です。

import java.nio.CharBuffer;
public class App {
    public static void main(String[] args) {
        CharBuffer charBuffer = CharBuffer.allocate(10);
        
        // 文字の書き込み
        charBuffer.put('A');
        charBuffer.put('B');
        
        // バッファの読み込み位置をリセット
        charBuffer.flip();
        
        // データの読み込み
        System.out.println("CharBufferのデータ: " + charBuffer.get() + ", " + charBuffer.get());
    }
}

CharBufferのデータ: A, B

IntBufferとの違い

IntBufferは、整数データを扱うためのバッファです。

ByteBufferはバイナリデータを扱うため、任意のデータ型を格納できますが、IntBufferは整数専用です。

IntBufferは、整数の配列を効率的に処理する際に便利です。

以下は、IntBufferの使用例です。

import java.nio.IntBuffer;
public class App {
    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(5);
        
        // 整数の書き込み
        intBuffer.put(1);
        intBuffer.put(2);
        
        // バッファの読み込み位置をリセット
        intBuffer.flip();
        
        // データの読み込み
        System.out.println("IntBufferのデータ: " + intBuffer.get() + ", " + intBuffer.get());
    }
}

IntBufferのデータ: 1, 2

FloatBufferとの違い

FloatBufferは、浮動小数点数データを扱うためのバッファです。

ByteBufferはバイナリデータを扱うため、任意のデータ型を格納できますが、FloatBufferは浮動小数点数専用です。

FloatBufferは、科学計算やグラフィックス処理など、浮動小数点数を多く扱うアプリケーションに適しています。

以下は、FloatBufferの使用例です。

import java.nio.FloatBuffer;
public class App {
    public static void main(String[] args) {
        FloatBuffer floatBuffer = FloatBuffer.allocate(5);
        
        // 浮動小数点数の書き込み
        floatBuffer.put(1.1f);
        floatBuffer.put(2.2f);
        
        // バッファの読み込み位置をリセット
        floatBuffer.flip();
        
        // データの読み込み
        System.out.println("FloatBufferのデータ: " + floatBuffer.get() + ", " + floatBuffer.get());
    }
}

FloatBufferのデータ: 1.1, 2.2

各Bufferの使い分け

スクロールできます

Bufferタイプ	用途	特徴
ByteBuffer	バイナリデータ全般	任意のデータ型を扱える
CharBuffer	文字データ(テキスト)	UTF-16エンコーディングで文字を格納
IntBuffer	整数データ	整数専用、効率的な整数処理が可能
FloatBuffer	浮動小数点数データ	浮動小数点数専用、科学計算やグラフィックスに適用

ByteBuffer: バイナリデータを扱う場合に使用します。

ファイルやネットワーク通信など、さまざまなデータ型を扱う際に便利です。

CharBuffer: 文字列やテキストデータを扱う場合に使用します。

特に、UTF-16エンコーディングが必要な場合に適しています。

IntBuffer: 整数データを効率的に処理する場合に使用します。

整数の配列を扱う際に便利です。

FloatBuffer: 浮動小数点数を多く扱うアプリケーション(科学計算やグラフィックス処理など)で使用します。

ByteBufferを使った実践例

ファイルからのデータ読み込み

ByteBufferを使用してファイルからデータを読み込むことができます。

以下の例では、ファイルをバイナリモードで開き、ByteBufferを使ってデータを読み込んでいます。

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class App {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("data.bin");
             FileChannel channel = fis.getChannel()) {
             
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = channel.read(buffer);
            
            // 読み込んだデータを表示
            System.out.println("読み込んだバイト数: " + bytesRead);
            buffer.flip(); // 読み込み位置をリセット
            
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get()); // バイトを文字に変換して表示
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

読み込んだバイト数: 10
HelloWorld

ネットワーク通信での使用

ByteBufferは、ネットワーク通信においても非常に便利です。

以下の例では、サーバーからデータを受信するクライアントを示しています。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
public class App {
    public static void main(String[] args) {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress("localhost", 12345));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            
            // データの受信
            socket.getInputStream().read(buffer.array());
            buffer.flip(); // 読み込み位置をリセット
            
            // 受信したデータを表示
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Hello from server

メモリマップファイルとの連携

ByteBufferは、メモリマップファイルを使用してファイルをメモリにマッピングすることもできます。

これにより、大きなファイルを効率的に扱うことができます。

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class App {
    public static void main(String[] args) {
        try (RandomAccessFile file = new RandomAccessFile("data.bin", "rw");
             FileChannel channel = file.getChannel()) {
             
            MappedByteBuffer mappedBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, channel.size());
            
            // データの読み込み
            while (mappedBuffer.hasRemaining()) {
                System.out.print((char) mappedBuffer.get());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HelloWorld

バイナリデータのシリアライズとデシリアライズ

ByteBufferを使用して、オブジェクトのシリアライズ(オブジェクトをバイト列に変換)とデシリアライズ(バイト列をオブジェクトに変換)を行うことができます。

以下の例では、簡単なオブジェクトをシリアライズしてファイルに書き込み、再度読み込んでデシリアライズしています。

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class App {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        // シリアライズ
        try (FileOutputStream fos = new FileOutputStream("person.dat")) {
            byte[] nameBytes = person.name.getBytes(StandardCharsets.UTF_8);
            // 名前の長さを格納するための Integer.BYTES と年齢を格納するための Integer.BYTES を追加
            ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES + nameBytes.length + Integer.BYTES);
            buffer.putInt(nameBytes.length); // 名前の長さを先に書き込む
            buffer.put(nameBytes);
            buffer.putInt(person.age);
            fos.write(buffer.array());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // デシリアライズ
        try (FileInputStream fis = new FileInputStream("person.dat")) {
            // ファイルサイズを正確に取得してバッファを作成
            byte[] fileContent = new byte[fis.available()];
            fis.read(fileContent);
            ByteBuffer buffer = ByteBuffer.wrap(fileContent);

            // 名前の長さを取得してから名前を取得
            int nameLength = buffer.getInt();
            byte[] nameBytes = new byte[nameLength];
            buffer.get(nameBytes);
            String name = new String(nameBytes, StandardCharsets.UTF_8);
            int age = buffer.getInt();

            System.out.println("名前: " + name + ", 年齢: " + age);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}