How to read a file into a String in Java

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        // Create the input file first (every run starts in an empty folder)
        Path path = Path.of("notes.txt");
        Files.writeString(path, "Compile\nRun\nShare\n");

        // Java 11+: the whole file as one String, decoded as UTF-8
        String content = Files.readString(path);

        System.out.print(content);
        System.out.println(content.length() + " chars");
        System.out.println(content.lines().count() + " lines");
        System.out.println(content.strip().toUpperCase());
    }
}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("todo.txt");
        Files.writeString(path, "buy milk\r\nfix bug\n\nship release");

        // One String per line, with the line terminators removed
        List<String> lines = Files.readAllLines(path);

        System.out.println(lines);
        System.out.println(lines.size() + " lines");
        for (int i = 0; i < lines.size(); i++) {
            System.out.println((i + 1) + ": " + lines.get(i));
        }

        // Join them back into one String with any separator
        System.out.println(String.join(" | ", lines));
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) throws IOException {
        // A 100,000-line log: big enough that you would not want it all in memory
        List<String> rows = new ArrayList<>();
        for (int i = 1; i <= 100_000; i++) {
            rows.add(i % 25_000 == 0 ? "ERROR disk full at line " + i : "INFO request " + i);
        }
        Path log = Path.of("app.log");
        Files.write(log, rows);

        // Files.lines is lazy: it reads as the stream pulls, one line at a time.
        // try-with-resources closes the file handle when the block ends.
        try (Stream<String> lines = Files.lines(log)) {
            lines.filter(line -> line.startsWith("ERROR"))
                 .limit(2)
                 .forEach(System.out::println);
        }

        // The classic loop: works on every Java version, and you control each step
        long count = 0;
        String last = null;
        try (BufferedReader reader = Files.newBufferedReader(log)) {
            String line;
            while ((line = reader.readLine()) != null) {
                count++;
                last = line;
            }
        }
        System.out.println(count + " lines, last: " + last);
    }
}

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws IOException {
        byte[] payload = "Grüße aus Köln\nline two".getBytes(StandardCharsets.UTF_8);

        // Java 9+: read every byte, then decode with an explicit charset
        try (InputStream in = new ByteArrayInputStream(payload)) {
            String text = new String(in.readAllBytes(), StandardCharsets.UTF_8);
            System.out.println(text);
        }

        // Java 9+ transferTo copies into any OutputStream (a file, a socket, a buffer)
        try (InputStream in = new ByteArrayInputStream(payload)) {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            long copied = in.transferTo(out);
            System.out.println(copied + " bytes -> " + out.toString(StandardCharsets.UTF_8).length() + " chars");
        }

        // A Reader decodes as it goes, which suits line-by-line processing
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(new ByteArrayInputStream(payload), StandardCharsets.UTF_8))) {
            String joined = reader.lines().collect(Collectors.joining(" / "));
            System.out.println(joined);
        }
    }
}

import java.io.IOException;
import java.nio.charset.MalformedInputException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws IOException {
        // 1. A file that does not exist
        try {
            Files.readString(Path.of("missing.txt"));
        } catch (NoSuchFileException e) {
            System.out.println("NoSuchFileException: " + e.getMessage());
        }

        // Or check first, and fall back to a default
        Path config = Path.of("config.txt");
        String text = Files.exists(config) ? Files.readString(config) : "(defaults)";
        System.out.println(text);

        // 2. A file saved in Latin-1 (ISO-8859-1), not UTF-8
        Path legacy = Path.of("legacy.txt");
        Files.writeString(legacy, "café", StandardCharsets.ISO_8859_1);
        System.out.println(Files.size(legacy) + " bytes on disk");

        try {
            Files.readString(legacy); // assumes UTF-8
        } catch (MalformedInputException e) {
            System.out.println("MalformedInputException: " + e.getMessage());
        }

        // Name the charset the file was written in
        System.out.println(Files.readString(legacy, StandardCharsets.ISO_8859_1));

        // new String(bytes) never throws: bad bytes become U+FFFD
        String lossy = new String(Files.readAllBytes(legacy), StandardCharsets.UTF_8);
        System.out.println(lossy + " " + lossy.codePointAt(3));
    }
}