HOWTO · Java

Java의 바이트 버퍼 클래스

Java ByteBuffer의 위치, 제한, 용량이 바이트 읽기 및 쓰기를 제어하는 방식, 버퍼를 만들고 사용하는 방법, 그리고 두 개의 Java 예제가 getChar()로 바이트와 문자를 읽는 방법을 알아봅니다.

이 페이지의 내용

ByteBuffer는 바이트를 저장하고 읽기 또는 쓰기를 위한 다음 위치를 추적합니다. 그 위치, 제한, 용량에 따라 연산이 액세스할 수 있는 바이트가 결정됩니다. 이 가이드는 그러한 상태 변화, 주요 생성 및 액세스 메서드, 그리고 두 개의 자체 완결형 Java 예제(바이트 값용 하나와 문자용 하나)를 설명합니다.

Java의 ByteBuffer 클래스

java.nio.ByteBuffer는 Java 코드와 I/O 채널 간에 이진 데이터를 이동하는 데 사용되는 바이트 지향 NIO 버퍼입니다. 기본 데이터로 일련의 정수를 저장하지 않습니다. putInt()와 같은 메서드는 버퍼의 바이트 순서를 사용하여 기본 값을 바이트로 인코딩합니다.

버퍼에는 세 가지 핵심 상태 값이 있습니다.

  • 용량은 버퍼의 고정 크기입니다.
  • 위치는 상대적 읽기 또는 쓰기가 사용할 다음 바이트의 인덱스입니다.
  • 제한은 읽거나 쓸 수 없는 첫 번째 인덱스입니다. 최대 용량입니다.

allocate()로 만든 새 버퍼는 위치가 0, 제한이 용량과 같고, 쓰인 데이터가 없습니다. 상대적 put()은 위치를 전진시킵니다. flip()을 호출하면 제한이 현재 위치로 설정되고 위치가 0으로 재설정되어 쓰인 바이트를 읽을 준비를 합니다. 상대적 get()은 읽으면서 위치를 전진시킵니다. clear()는 제한을 용량으로, 위치를 0으로 복원하여 전체 버퍼를 또 다른 쓰기를 위해 준비합니다. 바이트를 지우지는 않습니다. rewind()는 현재 제한을 유지하면서 위치를 0으로 재설정하므로, 같은 읽을 수 있는 영역을 다시 읽을 수 있습니다.

클래스 계층은 Object → Buffer → ByteBuffer입니다. 버퍼는 직접 또는 비직접일 수 있습니다. allocateDirect()는 일반 Java 힙 외부의 스토리지를 요청하며 일부 I/O 패턴에 유용할 수 있지만, 자동으로 더 빠르지는 않습니다. 직접 스토리지가 애플리케이션의 측정된 I/O 요구에 맞는 경우가 아니라면 allocate()를 선호하세요.

Java에서 ByteBuffer 클래스의 작동 범주

ByteBuffer 연산은 몇 가지 실용적인 그룹으로 나뉩니다.

  • 생성: allocate(capacity)는 힙 버퍼를 만들고, allocateDirect(capacity)는 직접 버퍼를 요청하며, wrap(byteArray)는 기존 바이트 배열을 버퍼를 통해 노출합니다.
  • 상대적 액세스: get()과 put(byte)는 현재 위치를 사용하고 이를 전진시킵니다. 그들의 대량 오버로드는 여러 바이트를 전송하고 전송된 수만큼 전진합니다.
  • 절대적 액세스: get(index)와 put(index, value)는 위치를 변경하지 않고 특정 인덱스를 지정합니다. 인덱스는 여전히 현재 제한 내에 있어야 합니다.
  • 기본 값 및 뷰: getInt(), putInt(value), getChar(), putChar(value)는 기본 값과 바이트 간에 변환합니다. order() 설정은 이러한 다중 바이트 값의 바이트 순서를 결정합니다. asIntBuffer()와 같은 뷰는 원래 버퍼의 위치를 변경하지 않고 바이트를 정수로 해석합니다.
  • 상태 및 파생 버퍼: position(), limit(), remaining(), slice(), duplicate(), compact(), rewind()를 통해 코드는 읽을 수 있고 쓸 수 있는 영역을 검사하거나 관리할 수 있습니다.

wrap() 메서드 계열은 기존 배열이 뒷받침하는 버퍼를 만듭니다. ByteBuffer.wrap(byte[])는 정수가 아닌 바이트를 래핑합니다. int[]를 래핑하려면 IntBuffer.wrap(intArray)를 사용하세요. 이는 정수 버퍼를 만들며 다른 API입니다. 바이트 배열은 ByteBuffer를 통해 바이트 시퀀스로 볼 수도 있으며, 그 바이트 순서에 따라 기본 값으로 해석될 수 있습니다.

Java의 바이트 버퍼 클래스 메서드

다음 메서드는 일반적인 생성, 상태, 데이터 액세스 작업을 다룹니다.

Method Purpose
allocate(int capacity) 요청된 용량의 힙 ByteBuffer를 만듭니다.
allocateDirect(int capacity) 직접 ByteBuffer를 만듭니다. 할당은 힙 스토리지와 비용이 다를 수 있습니다.
wrap(byte[] array) 제공된 바이트 배열이 뒷받침하는 버퍼를 만듭니다.
capacity() 고정 용량을 반환합니다.
position() / position(int) 다음 상대적 액세스 인덱스를 읽거나 설정합니다.
limit() / limit(int) 액세스 가능한 영역의 끝을 읽거나 설정합니다.
remaining() limit() - position()를 반환합니다.
get() / put(byte) 현재 위치에서 한 바이트를 읽거나 쓰고 이를 전진시킵니다.
get(int) / put(int, byte) 위치를 변경하지 않고 인덱스에서 읽거나 씁니다.
getInt() / putInt(int) and getChar() / putChar(char) 현재 바이트 순서를 사용하여 기본 값을 읽거나 씁니다.
order() / order(ByteOrder) 다중 바이트 기본 값에 사용되는 바이트 순서를 읽거나 설정합니다.
hasArray() / array() 액세스 가능한 뒷받침 바이트 배열을 확인하고 반환합니다. 직접 및 읽기 전용 버퍼는 하나를 노출하지 않을 수 있습니다.
isDirect() 버퍼가 직접인지 보고합니다.
flip() / clear() / rewind() 읽기, 쓰기 또는 다시 읽기를 위해 위치와 제한을 변경합니다.
slice() / duplicate() / compact() 뷰를 만들거나, 버퍼 상태를 관련 뷰로 복사하거나, 남은 바이트를 추가로 쓰기 위해 시작 부분으로 이동합니다.
asIntBuffer() 버퍼의 남은 바이트에 대한 정수 뷰를 만듭니다.

전체 API 세부 정보는 Java ByteBuffer 문서를 참조하세요.

Java에서 바이트 버퍼 구현

이 자체 완결형 예제는 두 개의 바이트 값을 쓰고, flip()으로 버퍼를 읽기 모드로 전환한 다음, 값을 읽습니다.

이 완전한 프로그램은 4바이트 버퍼를 할당하고, 두 값을 쓰고, 읽기를 위해 뒤집고, 값과 현재 상태를 출력합니다.

import java.nio.ByteBuffer;

public class ByteBufferBytes {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.put((byte) 20);
        buffer.put((byte) 40);
        buffer.flip();

        byte first = buffer.get();
        byte second = buffer.get();
        System.out.println("bytes=" + first + "," + second);
        System.out.println("position=" + buffer.position()
                + ", limit=" + buffer.limit()
                + ", capacity=" + buffer.capacity());
    }
}

예상 출력:

bytes=20,40
position=2, limit=2, capacity=4

두 번의 읽기 후 위치는 2입니다. 제한은 2로 유지되고 용량은 4로 유지됩니다. buffer.put(0, (byte) 7)와 같은 절대적 쓰기는 위치를 전진시키지 않고 인덱스 0의 바이트를 변경합니다. 상대적 쓰기는 현재 위치를 사용하고 이를 전진시킵니다. 위치 또는 제한 설정은 버퍼의 현재 상태에 의해 제한되므로, 위치를 그 너머로 이동하기 전에 제한을 설정하세요. remaining()은 위치와 제한 사이에 사용 가능한 바이트 수를 보고합니다.

Java에서 바이트 버퍼 클래스의 getChar 메서드 구현

getChar()는 현재 위치에서 두 바이트를 읽고 위치를 두 칸 전진시킵니다. 버퍼의 데이터 형식이 특정 순서를 요구할 때는 바이트 순서를 명시적으로 설정하세요. 이 예제는 putChar()로 네 개의 Java char 값을 쓰고, 버퍼를 뒤집고, 최소 Character.BYTES가 남아 있을 때만 읽습니다. 이는 알려진 바이트 수를 사용하여 안전하게 중지합니다. 0 문자에 종결자로 의존하지 않습니다.

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

public class ByteBufferChars {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(4 * Character.BYTES)
                .order(ByteOrder.BIG_ENDIAN);
        buffer.putChar('J');
        buffer.putChar('A');
        buffer.putChar('V');
        buffer.putChar('A');
        buffer.flip();

        StringBuilder text = new StringBuilder();
        while (buffer.remaining() >= Character.BYTES) {
            text.append(buffer.getChar());
        }
        System.out.println(text);

        buffer.rewind();
        char first = buffer.getChar();
        System.out.println("first=" + first);
    }
}

예상 출력:

JAVA
first=J

Java char는 UTF-16 코드 단위이며, getChar()는 임의의 UTF-8 바이트 시퀀스를 디코딩하지 않습니다. UTF-8로 저장된 텍스트의 경우 바이트를 읽고 StandardCharsets.UTF_8와 같은 Charset으로 디코딩하세요. 이 고정 너비 예제의 경우 버퍼 크기는 문자당 정확히 2바이트이며, 남은 바이트 검사는 각 getChar()에 2바이트가 사용 가능함을 보장합니다. 그런 다음 rewind()는 같은 영역을 다시 읽을 수 있게 하여 마지막 읽기가 첫 번째 문자를 가져올 수 있게 합니다.