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

public class ReadingFiles {

    // Reading files requires checking most calls for exceptions.
    // This helper will streamline our exception handling below.
    private static void check(Exception e) {
        if (e != null) {
            throw new RuntimeException(e);
        }
    }

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

        // You'll often want more control over how and what
        // parts of a file are read. For these tasks, start
        // by creating a FileInputStream to obtain a file handle.
        try (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 location in the file
            // and read from there.
            long o2 = fis.getChannel().position(6);
            byte[] b2 = new byte[2];
            int n2 = fis.read(b2);
            System.out.printf("%d bytes @ %d: ", n2, o2);
            System.out.printf("%s\n", new String(b2, 0, n2));

            // Other methods of seeking are relative to the
            // current cursor position,
            fis.getChannel().position(fis.getChannel().position() + 4);

            // and relative to the end of the file.
            fis.getChannel().position(fis.getChannel().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.
            fis.getChannel().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
            // fis.getChannel().position(0) accomplishes this.
            fis.getChannel().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 r4 = new BufferedReader(new InputStreamReader(fis));
            char[] b4 = new char[5];
            r4.mark(5);
            r4.read(b4, 0, 5);
            System.out.printf("5 bytes: %s\n", new String(b4));
            r4.reset();

            // The file is closed automatically when the try-with-resources block ends
        } catch (IOException e) {
            check(e);
        }
    }
}