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

public class ReadingFiles {
    // This helper method will streamline our error checks
    private static void check(Exception e) {
        if (e != null) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        try {
            // Perhaps the most basic file reading task is
            // slurping a file's entire contents into memory.
            String content = new String(Files.readAllBytes(Paths.get("/tmp/dat")));
            System.out.print(content);

            // You'll often want more control over how and what
            // parts of a file are read. For these tasks, start
            // by creating a FileInputStream.
            FileInputStream fis = new FileInputStream("/tmp/dat");

            // Read some bytes from the beginning of the file.
            // Allow up to 5 to be read but also note how many
            // actually were read.
            byte[] b1 = new byte[5];
            int n1 = fis.read(b1);
            System.out.printf("%d bytes: %s\n", n1, new String(b1, 0, n1));

            // You can also seek to a known position in the file
            // and read from there.
            fis.getChannel().position(6);
            byte[] b2 = new byte[2];
            int n2 = fis.read(b2);
            System.out.printf("%d bytes @ %d: ", n2, 6);
            System.out.printf("%s\n", new String(b2, 0, n2));

            // Seeking relative to the current position and end of file
            // can be done using FileChannel
            FileChannel channel = fis.getChannel();
            channel.position(channel.position() + 4);
            channel.position(channel.size() - 10);

            // The java.io package provides some classes that may
            // be helpful for file reading. For example, reads
            // like the ones above can be more robustly
            // implemented with BufferedInputStream.
            channel.position(6);
            BufferedInputStream bis = new BufferedInputStream(fis);
            byte[] b3 = new byte[2];
            int n3 = bis.read(b3);
            System.out.printf("%d bytes @ %d: %s\n", n3, 6, new String(b3));

            // There is no built-in rewind, but
            // seeking to the start accomplishes this.
            channel.position(0);

            // The BufferedReader class implements a buffered
            // reader that may be useful both for its efficiency
            // with many small reads and because of the additional
            // reading methods it provides.
            BufferedReader reader = new BufferedReader(new FileReader("/tmp/dat"));
            char[] b4 = new char[5];
            reader.mark(5);
            reader.read(b4, 0, 5);
            System.out.printf("5 bytes: %s\n", new String(b4));

            // Close the file when you're done (usually this would
            // be scheduled immediately after opening with
            // try-with-resources).
            fis.close();
            reader.close();

        } catch (IOException e) {
            check(e);
        }
    }
}