Open: примеры (JAVA)

Короткие примеры

Открытие файла только для чтения и чтение первого блока:

Path p = Paths.get("example.txt");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.READ)) {
    ByteBuffer buf = ByteBuffer.allocate(64);
    int r = ch.read(buf);
    buf.flip();
    byte[] data = new byte[buf.remaining()];
    buf.get(data);
    System.out.println(new String(data));
} catch (IOException e) {
    e.printStackTrace();
}

(в консоль может быть выведено первые 64 байта файла example.txt)

Создание и запись текста в файл с использованием CREATE и TRUNCATE_EXISTING:

Path p = Paths.get("out.txt");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) {
    ByteBuffer buf = ByteBuffer.wrap("Hello FileChannel".getBytes());
    ch.write(buf);
} catch (IOException e) {
    e.printStackTrace();
}

(в результате файл out.txt будет содержать строку "Hello FileChannel")

Открытие для добавления (append):

Path p = Paths.get("out.txt");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
    ByteBuffer buf = ByteBuffer.wrap("\nAppend line".getBytes());
    ch.write(buf);
} catch (IOException e) {
    e.printStackTrace();
}

(в файл будет добавлена новая строка в конце)

Похожие возможности в Java

• Files.newInputStream / newOutputStream - более высокоуровневые потоки для последовательного чтения/записи. Удобнее для простых задач, при этом меньше контроля над позиционированием и блокировками.
• RandomAccessFile - обеспечивает чтение и запись с указанием позиции, но использует классические потоки и не интегрируется напрямую с NIO ByteBuffer.
• AsynchronousFileChannel - асинхронный ввод-вывод с колбэками или Future, предпочтителен при неблокирующем взаимодействии и высокой параллельности.
• Files.newByteChannel - более универсальный фабричный метод, возвращающий SeekableByteChannel, иногда предпочтителен при работе с наборами опций в виде Set.

Выбор зависит от требований: для низкоуровневых операций, memory-mapped IO и трансфера каналов предпочтительнее FileChannel. Для простого последовательного ввода-вывода достаточно Files или классических потоков.

Эквиваленты в других языках

Краткое сравнение с кодом и ожидаемым результатом.

PHP: fopen

$f = fopen('example.txt', 'r');
$data = fread($f, 64);
fclose($f);
echo $data;

(первые 64 байта файла будут выведены)

Node.js (JavaScript): fs.open / fs.read

const fs = require('fs');
fs.open('example.txt', 'r', (err, fd) => {
  const buf = Buffer.alloc(64);
  fs.read(fd, buf, 0, 64, 0, (err, bytes) => {
    console.log(buf.toString('utf8', 0, bytes));
    fs.close(fd, ()=>{});
  });
});

(первые 64 байта файла будут выведены в консоль)

Python: встроенная open

with open('example.txt', 'rb') as f:
    print(f.read(64))

b'...' (64 байта в виде байтовой строки)

C#: FileStream и File.Open

using(var fs = File.Open("example.txt", FileMode.Open, FileAccess.Read))
{
    byte[] buf = new byte[64];
    int r = fs.Read(buf, 0, buf.Length);
    Console.WriteLine(Encoding.UTF8.GetString(buf,0,r));
}

(первые 64 байта файла будут выведены)

Go: os.Open и os.OpenFile

f, _ := os.Open("example.txt")
b := make([]byte, 64)
n, _ := f.Read(b)
fmt.Println(string(b[:n]))
f.Close()

(первые 64 байта файла будут выведены)

Kotlin: использует Java NIO напрямую, можно вызвать FileChannel.open или удобные расширения из stdlib:

val path = Paths.get("example.txt")
FileChannel.open(path, StandardOpenOption.READ).use { ch ->
    val buf = ByteBuffer.allocate(64)
    ch.read(buf)
    buf.flip()
    println(Charsets.UTF_8.decode(buf))
}

(первые 64 байта будут напечатаны)

Отличия: в большинстве языков базовые операции аналогичны. Java NIO предоставляет богатый набор флагов открытия, прямую работу с буферами и методы типа transferTo и map, которых нет в простых обертках других языков без дополнительных API.

Типичные ошибки и причины

• NoSuchFileException - попытка открыть несуществующий файл в режиме чтения. Пример:

  FileChannel.open(Paths.get("no.txt"), StandardOpenOption.READ);

  java.nio.file.NoSuchFileException: no.txt

• FileAlreadyExistsException - использование CREATE_NEW при наличии файла:

  FileChannel.open(Paths.get("exist.txt"), StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);

  java.nio.file.FileAlreadyExistsException: exist.txt

• AccessDeniedException / SecurityException - недостаточно прав для чтения или записи. Частая причина при попытке писать в системные каталоги.
• IllegalArgumentException или UnsupportedOperationException - переданы неподдерживаемые опции или комбинации флагов (например, APPEND без WRITE на некоторых реализациях).
• Блокировки и взаимоблокировки - при попытке получить блокировку с пересечением регионов или при одновременном использовании каналов без синхронизации возможны блокировки; использование tryLock и обработка OverlappingFileLockException помогает диагностировать проблему.

Изменения и история

Метод с сигнатурой, принимающей Path, появился в Java 7 вместе с NIO.2 и набором стандартных опций StandardOpenOption. До этого для работы с каналами применялись конструкторы потоков и RandomAccessFile. В последующих релизах API не подвергался крупным изменениям, однако появились сопутствующие механизмы: AsynchronousFileChannel, улучшенные реализации файловых систем в составе JDK и расширенная поддержка атрибутов файлов (POSIX ACL и др.). Также развивались оптимизации и поведение синхронизации force на разных платформах.

Расширенные и редко встречающиеся примеры

1) Memory-mapped файл и читатель больших данных:

Path p = Paths.get("big.dat");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.READ)) {
    MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0, ch.size());
    byte b = mb.get(0); // доступ к байтам через буфер, эффективная работа с большими файлами
    System.out.println(b);
} catch (IOException e) {
    e.printStackTrace();
}

(в консоль выведен первый байт файла big.dat в виде числа)

2) Нулевое копирование: копирование файла через transferTo:

Path src = Paths.get("src.bin");
Path dst = Paths.get("dst.bin");
try (FileChannel in = FileChannel.open(src, StandardOpenOption.READ);
     FileChannel out = FileChannel.open(dst, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) {
    long pos = 0;
    long size = in.size();
    while (pos < size) {
        pos += in.transferTo(pos, size - pos, out);
    }
} catch (IOException e) {
    e.printStackTrace();
}

(файл dst.bin станет идентичен src.bin; на некоторых платформах используется нулевое копирование)

3) Множественные буферы: scatter/gather чтение и запись:

Path p = Paths.get("record.bin");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.READ)) {
    ByteBuffer header = ByteBuffer.allocate(16);
    ByteBuffer body = ByteBuffer.allocate(128);
    ByteBuffer[] bufs = new ByteBuffer[]{header, body};
    long r = ch.read(bufs);
    header.flip(); body.flip();
    // обработка header и body отдельно
} catch (IOException e) {
    e.printStackTrace();
}

(буфер header получит первые 16 байт, body следующие 128 байт)

4) Блокировка участка файла и совместная работа процессов:

Path p = Paths.get("shared.dat");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.READ)) {
    FileLock lock = ch.lock(0, 1024, false); // эксклюзивная блокировка первых 1024 байт
    try {
        // безопасная запись в регион
    } finally {
        lock.release();
    }
} catch (IOException e) {
    e.printStackTrace();
}

(первый килобайт файла будет заблокирован на время работы блока)

5) Создание файла с POSIX-пермишенами при создании (Unix):

Set perms = PosixFilePermissions.fromString("rw-r-----");
FileAttribute> attr = PosixFilePermissions.asFileAttribute(perms);
Path p = Paths.get("secure.txt");
try (FileChannel ch = FileChannel.open(p, EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE), attr)) {
    ch.write(ByteBuffer.wrap("secret".getBytes()));
} catch (IOException e) {
    e.printStackTrace();
}

(файл secure.txt создается с указанными POSIX-пермишенами)

6) Параллельная запись с явным позиционированием (без APPEND):

Path p = Paths.get("blocks.bin");
try (FileChannel ch = FileChannel.open(p, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    ByteBuffer buf = ByteBuffer.wrap(new byte[4096]);
    // запись в определенные смещения, подходящая для параллельных задач
    ch.position(1024 * 100);
    ch.write(buf);
    ch.force(true);
} catch (IOException e) {
    e.printStackTrace();
}

(в файл записывается блок по смещению 102400 байт)

Пояснения: использование FileChannel дает контроль над позицией и синхронизацией. При работе с большими данными и частыми операциями позиционирования преимущества выражены сильнее, чем у потоков высокого уровня.