Lessons

This lecture covers line-by-line reading with BufferedReader and whole-file reading via Files.readAllLines/ Files.readString, choosing a buffer (for example, 8192 bytes), safe resource closing with try-with-resources, and working with charsets ( StandardCharsets.UTF_8). It includes practical examples (counting lines, searching logs, parsing configuration) and common pitfalls (for example, OutOfMemoryError when loading large files at once).

We cover the difference between text and binary files, the basic byte streams InputStream/ OutputStream and their file implementations ( FileInputStream, FileOutputStream). We write buffered copy, discuss read speed one byte at a time vs in blocks, writing byte arrays via write(), try-with-resources nuances, choosing a buffer size of 4– 16 KB, safe use of readAllBytes(), and common pitfalls (for example, using FileReader/ FileWriter for binary data).

In this lecture, we examine binary I/O in Java using DataInputStream and DataOutputStream: how to write and read primitives ( int, double, boolean) and strings ( String) with writeXXX/ readXXX methods, why order matters, how to store arrays, when it makes sense to add BufferedInputStream/ BufferedOutputStream, and which common mistakes lead to IOException or EOFException.

We break down the modern way to handle resources safely in Java — try-with-resources: a comparison with the old try/ catch/ finally + close() pattern, type requirements (implementing AutoCloseable or Closeable), the try(...){...} syntax, close order, “suppressed” exceptions via getSuppressed(), examples with I/O streams and custom resources, as well as tips and common mistakes.

We explain what character encoding is and why, without it, computer text turns into “mojibake.” We compare popular sets: UTF-8, Windows-1251, ASCII, Unicode/ UTF-16. We discuss the internal representation of strings in the JVM ( String in Unicode) and proper input/output: explicitly specifying the encoding via InputStreamReader/ OutputStreamWriter and StandardCharsets.UTF_8. Finally — practical examples and common mistakes.

We break down three basic encodings a Java developer encounters: what UTF-8 is (the standard for the web and most formats), how the internal string format in the JVM works — UTF-16 (with surrogate pairs and BOM), and why ISO-8859-1 still appears. We explain compatibility with ASCII, bytes per character, and demonstrate correct encoding handling in Java using StandardCharsets, Files.write, Files.readString, Paths.get. Finally, we cover typical pitfalls: incorrect read/write, the system “default” encoding, confusion between UTF-16/ UTF-8.

How to avoid “mojibake” and make text look the same on all machines: examine the system encoding ( "file.encoding"), work with Charset and the constants in StandardCharsets, read/write via Files . newBufferedReader and Files . newBufferedWriter, use try-with-resources, check available encodings, and follow best practices (by default — "UTF-8"). Finally — common mistakes and how to avoid them.

In this lecture we examine “mojibake”, character loss ( ?), exceptions like MalformedInputException, the causes (mismatch between Windows-1251/ UTF-8, the system default encoding, BOM), diagnostics ( file.encoding), and best practices: explicitly specifying a Charset, using Files/ BufferedReader with StandardCharsets, avoiding FileReader/ FileWriter, and nuances for XML/ JSON and BOM.

How to correctly read text from a file in one encoding and write it in another using classes from java.nio.file and java.io: use Files.newBufferedReader/ Files.newBufferedWriter or InputStreamReader/ OutputStreamWriter, specify the required Charset, apply try-with-resources, and avoid pitfalls of the system default encoding. Step-by-step algorithm, Windows-1251 → UTF-8 example, nuances (BOM, large files, exceptions), and common mistakes.

How the I/O exceptions hierarchy in Java is structured, the difference between IOException and its subclass FileNotFoundException, when they occur, and how to handle them correctly. We will cover the order of catch blocks, hands-on file reading/writing, logging tips, as well as a brief table of the most frequent errors. We will touch on checked exceptions, the keywords try, catch, finally, throws, and the try-with-resources construct.

How to check in Java whether a file or folder exists: the File class with its methods exists(), isFile(), isDirectory(), and the modern NIO approach via Path and Files — Files.exists(), Files.isRegularFile(), Files.isDirectory(). We will discuss the TOCTOU problem and why a pre-check does not replace error handling: even after exists() you can still get FileNotFoundException or AccessDeniedException, so always use try blocks and, when possible, try-with-resources. Plus hands-on practice: reading a file if present, creating a directory with Files.createDirectory() and Files.createDirectories(), working with relative and absolute paths.

How to recognize “broken” files by exceptions ( EOFException, MalformedInputException, ZipException, StreamCorruptedException), what to do when the format does not match, and which recovery strategies to use: logging and notifying the user, partial reading up to the error, backups, checksums ( SHA-256). Practice reading until EOF, correct handling of encodings, and analysis of common mistakes (validation, try-with-resources, careful overwrite).