import java.nio.file.*;
import java.nio.channels.SeekableByteChannel;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class ChannelOpener {
    
    public void openForRead(Path file) throws IOException {
        // Открываем только для чтения
        try (SeekableByteChannel channel = Files.newByteChannel(file, StandardOpenOption.READ)) {
            System.out.println("Размер файла: " + channel.size());
            System.out.println("Текущая позиция: " + channel.position());
        }
    }
    
    public void openForWrite(Path file) throws IOException {
        // Открываем для чтения и записи, создаём если нет, обрезаем если есть
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ,
                StandardOpenOption.WRITE,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
            
            // Записываем данные
            ByteBuffer buffer = ByteBuffer.wrap("Hello, World".getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
    }
}

public class RandomAccessExample {
    
    public void readFromPosition(Path file, long position, int length) throws IOException {
        try (SeekableByteChannel channel = Files.newByteChannel(file, StandardOpenOption.READ)) {
            // Устанавливаем позицию
            channel.position(position);
            
            ByteBuffer buffer = ByteBuffer.allocate(length);
            int bytesRead = channel.read(buffer);
            
            buffer.flip();  // переключаем буфер из режима записи в режим чтения
            byte[] data = new byte[bytesRead];
            buffer.get(data);
            
            System.out.println("Прочитано с позиции " + position + ": " + new String(data));
        }
    }
    
    public void writeAtPosition(Path file, long position, String data) throws IOException {
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ, StandardOpenOption.WRITE)) {
            
            channel.position(position);
            
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
            
            // После записи позиция сдвинулась на количество записанных байт
            System.out.println("Новая позиция: " + channel.position());
        }
    }
    
    public void appendToFile(Path file, String data) throws IOException {
        // Способ 1: через APPEND опцию
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
        
        // Способ 2: через position(size()) — ручное позиционирование в конец
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ, StandardOpenOption.WRITE)) {
            channel.position(channel.size());  // переходим в конец
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
    }
}

// Старый способ (RandomAccessFile)
try (RandomAccessFile raf = new RandomAccessFile("data.bin", "rw")) {
    raf.seek(100);  // позиционирование
    raf.write("data".getBytes());
}

// Новый способ (SeekableByteChannel)
try (SeekableByteChannel channel = Files.newByteChannel(Paths.get("data.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    channel.position(100);
    channel.write(ByteBuffer.wrap("data".getBytes()));
}

import java.nio.file.*;
import java.io.IOException;

public class HardLinkManager {
    
    public void createHardLink(Path existingFile, Path newLink) throws IOException {
        // Проверяем, что исходный файл существует и на той же файловой системе
        if (!Files.isRegularFile(existingFile)) {
            throw new IllegalArgumentException("Исходный файл не существует или не является обычным файлом");
        }
        
        // createLink создаёт жёсткую ссылку
        Files.createLink(newLink, existingFile);
        
        // Проверяем: оба пути указывают на один inode
        Object key1 = Files.readAttributes(existingFile, BasicFileAttributes.class).fileKey();
        Object key2 = Files.readAttributes(newLink, BasicFileAttributes.class).fileKey();
        
        if (key1 != null && key1.equals(key2)) {
            System.out.println("Жёсткая ссылка создана. Оба пути указывают на inode " + key1);
        }
    }
}

public class SymlinkManager {
    
    public void createSymlink(Path link, Path target) throws IOException {
        // Создаём символическую ссылку
        // target может быть абсолютным или относительным
        Files.createSymbolicLink(link, target);
    }
    
    public void createRelativeSymlink(Path linkDir, Path targetFile) throws IOException {
        // Строим относительный путь от linkDir до targetFile
        Path relativeTarget = linkDir.relativize(targetFile);
        Path link = linkDir.resolve("shortcut");
        
        Files.createSymbolicLink(link, relativeTarget);
    }
    
    public void inspectSymlink(Path link) throws IOException {
        if (!Files.isSymbolicLink(link)) {
            System.out.println("Это не символическая ссылка");
            return;
        }
        
        // Читаем целевой путь, хранящийся в ссылке
        Path target = Files.readSymbolicLink(link);
        System.out.println("Ссылка указывает на: " + target);
        
        // Проверяем, существует ли целевой объект
        if (Files.exists(link)) {
            System.out.println("Целевой объект существует");
            
            // Читаем атрибуты целевого объекта (следуем по ссылке)
            BasicFileAttributes attrs = Files.readAttributes(link, BasicFileAttributes.class);
            System.out.println("Тип цели: " + (attrs.isDirectory() ? "директория" : "файл"));
        } else {
            System.out.println("Висячая ссылка — цель не существует");
        }
        
        // Читаем атрибуты самой ссылки (не следуем по ней)
        BasicFileAttributes linkAttrs = Files.readAttributes(
            link, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS
        );
        System.out.println("Размер самой ссылки: " + linkAttrs.size() + " байт (длина пути)");
    }
}

public class SafeTreeWalker {
    
    // ОПАСНО: может зациклиться, если есть symlink на предка
    public void dangerousWalk(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root, FileVisitOption.FOLLOW_LINKS)) {
            stream.forEach(System.out::println);  // риск бесконечного цикла
        }
    }
    
    // БЕЗОПАСНО: не следуем по символическим ссылкам
    public void safeWalk(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root)) {  // без FOLLOW_LINKS
            stream.forEach(System.out::println);
        }
    }
    
    // БЕЗОПАСНО: следуем по ссылкам, но отслеживаем посещённые inode
    public void safeWalkWithCycleDetection(Path root) throws IOException {
        Set<Object> visitedInodes = new HashSet<>();
        
        Files.walkFileTree(root, EnumSet.of(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE,
            new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                    Object key = attrs.fileKey();
                    if (key != null) {
                        if (visitedInodes.contains(key)) {
                            System.out.println("Обнаружен цикл через ссылку: " + file);
                            return FileVisitResult.SKIP_SIBLINGS;
                        }
                        visitedInodes.add(key);
                    }
                    System.out.println(file);
                    return FileVisitResult.CONTINUE;
                }
            }
        );
    }
}

import java.nio.channels.SeekableByteChannel;
import java.nio.file.*;
import java.nio.*;

public class Task270726 {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("test.txt");
        try (SeekableByteChannel ch = Files.newByteChannel(path,
                StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.READ)) {
            ch.write(ByteBuffer.wrap("Hello".getBytes())); 
            ch.position(10);                
            ch.write(ByteBuffer.wrap("World".getBytes())); 
            System.out.println(ch.size());
        }
    }
}

import java.util.Arrays;

public class ArrayCopyPerformance {
    
    public static void main(String[] args) {
        int[] src = new int[1000000];
        for (int i = 0; i < src.length; i++) src[i] = i;
        
        //Медленно: ручной цикл
        int[] dest1 = new int[src.length];
        for (int i = 0; i < src.length; i++) {
            dest1[i] = src[i];
        }
        
        //Быстро: System.arraycopy
        int[] dest2 = new int[src.length];
        System.arraycopy(src, 0, dest2, 0, src.length);
        
        //Удобно: Arrays.copyOf (использует arraycopy внутри)
        int[] dest3 = Arrays.copyOf(src, src.length);
        
        // Частичное копирование
        int[] destPartial = new int[100];
        System.arraycopy(src, 500, destPartial, 0, 100); // копируем 100 элементов с позиции 500
        
        // Опасность с объектами
        String[] strings = {"a", "b", "c"};
        Object[] objects = new Object[3];
        System.arraycopy(strings, 0, objects, 0, 3); // OK: String[] -> Object[]
        
        try {
            // Ошибка: несовместимые типы
            Integer[] ints = {1, 2, 3};
            System.arraycopy(ints, 0, strings, 0, 3); // ArrayStoreException
        } catch (ArrayStoreException e) {
            System.err.println("Типы несовместимы: " + e);
        }
        
        // Для примитивов проверка осуществляется во время выполнения
        // но совместимость гарантируется компилятором, если типы одинаковы
    }
}

public class Task280726 {
    public static void main(String[] args) {
        Object[] src = {"A", "B", 1};
        String[] dest = new String[3];
        System.arraycopy(src, 0, dest, 0, 3);
        System.out.println(dest[0]);
    }
}