import java.io.IOException;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.AccessMode;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.FileStore;
import java.nio.file.FileSystem;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileAttributeView;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.UserPrincipalLookupService;
import java.nio.file.spi.FileSystemProvider;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import java.util.zip.ZipFile;

public class Program {

    public static void main(String[] args) throws IOException {
        String fileName = "test.zip";
        byte[] bytes = Files.readAllBytes(Path.of(fileName));
        System.out.println(Arrays.toString(bytes));
        try (ZipFile zipFile = new ZipFile(fileName)) {
        }
    }

    public static class CustomFileSystemProvider extends FileSystemProvider {

        public CustomFileSystemProvider(FileSystemProvider provider) {
        }

        @Override
        public String getScheme() {
            return "file";
        }

        @Override
        public FileSystem newFileSystem(URI uri, Map<String, ?> env) {
            return new CustomFileSystem();
        }

        @Override
        public FileSystem getFileSystem(URI uri) {
            return new CustomFileSystem();
        }

        @Override
        public Path getPath(URI uri) {
            throw new UnsupportedOperationException();
        }

        @Override
        public SeekableByteChannel newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs) {
            return new CustomSeekableByteChannel();
        }

        @Override
        public DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void createDirectory(Path dir, FileAttribute<?>... attrs) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void delete(Path path) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void copy(Path source, Path target, CopyOption... options) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void move(Path source, Path target, CopyOption... options) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean isSameFile(Path path, Path path2) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean isHidden(Path path) {
            return false;
        }

        @Override
        public FileStore getFileStore(Path path) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void checkAccess(Path path, AccessMode... modes) {
            throw new UnsupportedOperationException();
        }

        @Override
        public <V extends FileAttributeView> V getFileAttributeView(Path path, Class<V> type, LinkOption... options) {
            throw new UnsupportedOperationException();
        }

        @Override
        public <A extends BasicFileAttributes> A readAttributes(Path path, Class<A> type, LinkOption... options) {
            return (A) new CustomBasicFileAttributes();
        }

        @Override
        public Map<String, Object> readAttributes(Path path, String attributes, LinkOption... options) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void setAttribute(Path path, String attribute, Object value, LinkOption... options) {
            throw new UnsupportedOperationException();
        }

        private class CustomFileSystem extends FileSystem {

            @Override
            public FileSystemProvider provider() {
                return CustomFileSystemProvider.this;
            }

            @Override
            public void close() {
            }

            @Override
            public boolean isOpen() {
                return true;
            }

            @Override
            public boolean isReadOnly() {
                return false;
            }

            @Override
            public String getSeparator() {
                throw new UnsupportedOperationException();
            }

            @Override
            public Iterable<Path> getRootDirectories() {
                throw new UnsupportedOperationException();
            }

            @Override
            public Iterable<FileStore> getFileStores() {
                throw new UnsupportedOperationException();
            }

            @Override
            public Set<String> supportedFileAttributeViews() {
                throw new UnsupportedOperationException();
            }

            @Override
            public Path getPath(String first, String... more) {
                return new CustomPath();
            }

            @Override
            public PathMatcher getPathMatcher(String syntaxAndPattern) {
                throw new UnsupportedOperationException();
            }

            @Override
            public UserPrincipalLookupService getUserPrincipalLookupService() {
                throw new UnsupportedOperationException();
            }

            @Override
            public WatchService newWatchService() throws IOException {
                throw new UnsupportedOperationException();
            }

            private class CustomPath implements Path {

                @Override
                public FileSystem getFileSystem() {
                    return CustomFileSystem.this;
                }

                @Override
                public boolean isAbsolute() {
                    return false;
                }

                @Override
                public Path getRoot() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path getFileName() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path getParent() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public int getNameCount() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path getName(int index) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path subpath(int beginIndex, int endIndex) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public boolean startsWith(Path other) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public boolean endsWith(Path other) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path normalize() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path resolve(Path other) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path relativize(Path other) {
                    throw new UnsupportedOperationException();
                }

                @Override
                public URI toUri() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path toAbsolutePath() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public Path toRealPath(LinkOption... options) throws IOException {
                    throw new UnsupportedOperationException();
                }

                @Override
                public WatchKey register(WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers) throws IOException {
                    throw new UnsupportedOperationException();
                }

                @Override
                public int compareTo(Path other) {
                    throw new UnsupportedOperationException();
                }
            }
        }

        private class CustomBasicFileAttributes implements BasicFileAttributes {

            @Override
            public FileTime lastModifiedTime() {
                return FileTime.fromMillis(0);
            }

            @Override
            public FileTime lastAccessTime() {
                return FileTime.fromMillis(0);
            }

            @Override
            public FileTime creationTime() {
                return FileTime.fromMillis(0);
            }

            @Override
            public boolean isRegularFile() {
                return true;
            }

            @Override
            public boolean isDirectory() {
                return false;
            }

            @Override
            public boolean isSymbolicLink() {
                return false;
            }

            @Override
            public boolean isOther() {
                return false;
            }

            @Override
            public long size() {
                return 2;
            }

            @Override
            public Object fileKey() {
                throw new UnsupportedOperationException();
            }
        }

        private class CustomSeekableByteChannel implements SeekableByteChannel {

            private boolean written = false;

            @Override
            public int read(ByteBuffer dst) {
                if (this.written) {
                    return 0;
                }
                this.written = true;
                dst.put((byte) 13);
                dst.put((byte) 37);
                return 2;
            }

            @Override
            public int write(ByteBuffer src) {
                throw new UnsupportedOperationException();
            }

            @Override
            public long position() {
                throw new UnsupportedOperationException();
            }

            @Override
            public SeekableByteChannel position(long newPosition) {
                throw new UnsupportedOperationException();
            }

            @Override
            public long size() throws IOException {
                return 2;
            }

            @Override
            public SeekableByteChannel truncate(long size) {
                throw new UnsupportedOperationException();
            }

            @Override
            public boolean isOpen() {
                return true;
            }

            @Override
            public void close() {
            }
        }
    }
}