Best practices: 1) Use try-with-resources for automatic closure, 2) Close resources in finally block if not using try-with-resources, 3) Close in reverse order of creation, 4) Handle exceptions during close, 5) Use appropriate buffer sizes, 6) Don't suppress exceptions. Consider using utility libraries (Apache Commons IO, Guava) for simplified resource management.
Attributes include: basic (size, times, permissions), DOS, POSIX, ACL, user-defined. Access through: Files.getAttribute(), Files.readAttributes(), FileAttributeView. Platform-specific attributes handled through specific views. Security considerations: privilege requirements, symbolic link handling. Remember platform differences.
RandomAccessFile: traditional API, synchronized methods, simpler interface. FileChannel: modern API, better performance, more features (memory mapping, locks, etc.). FileChannel advantages: non-blocking operations, bulk transfers, direct buffers. Choose based on: requirements, compatibility needs, performance needs.
Memory-mapped files (MappedByteBuffer) map file content directly to memory. Advantages: 1) Faster access for large files, 2) OS-level optimization, 3) Direct memory access. Best for: large files, random access patterns, shared memory between processes. Limitations: file size constraints, resource management needed. Use FileChannel.map() to create mapping.
Serialization converts objects to byte streams for storage/transmission. Requires Serializable interface. Limitations: 1) Performance overhead, 2) Security risks, 3) Version compatibility issues, 4) All referenced objects must be serializable, 5) Transient fields not serialized. Alternatives: JSON/XML serialization, custom serialization, externalization. Consider security implications when deserializing.
WatchService monitors directory for changes (create, modify, delete). Features: 1) Asynchronous notification, 2) Multiple directory monitoring, 3) Platform-specific optimizations. Implementation: register Path with WatchService, process WatchEvents in loop. Considerations: event coalescing, overflow handling, platform differences in sensitivity.
Strategies: 1) Memory-mapped files for random access, 2) Buffered streams for sequential access, 3) Stream API for processing, 4) Chunked reading/writing, 5) NIO channels for better performance. Consider: memory constraints, access patterns, threading model. Monitor memory usage, use profiling tools. Handle exceptions and cleanup properly.
Absolute paths: complete path from root. Relative paths: relative to current directory. Canonical paths: absolute with symbolic links resolved, redundancies removed. Path.normalize() removes redundancies but doesn't resolve links. Canonical paths useful for comparison, security checks. Consider platform differences in path handling.
Methods: Files.createTempFile(), Files.createTempDirectory(). Best practices: 1) Use try-with-resources, 2) Set appropriate permissions, 3) Clean up on exit, 4) Handle name collisions, 5) Consider security implications. Use deleteOnExit() cautiously. Remember platform differences in temp directory location and cleanup.
Key differences: 1) I/O is stream-oriented, NIO is buffer-oriented, 2) I/O operations are blocking, NIO supports non-blocking mode, 3) NIO uses channels and selectors for multiplexing, 4) NIO provides better performance for large files through memory mapping, 5) NIO offers better file system APIs through Path interface. Old I/O simpler for small files and straightforward operations.
InputStream/OutputStream handle binary data (bytes), while Reader/Writer handle character data with encoding/decoding support. Reader/Writer use character encodings (UTF-8, etc.), making them suitable for text processing. InputStreamReader/OutputStreamWriter bridge between byte and character streams. Choose based on data type: binary (streams) or text (readers/writers).
Java handles cross-platform paths through: 1) File.separator for OS-specific separator, 2) Path interface normalizing paths, 3) Paths.get() factory methods accepting variable arguments, 4) FileSystem abstraction for custom providers. Best practices: use Path interface, avoid hardcoded separators, use relative paths when possible, handle case sensitivity differences.
Methods: 1) Properties class load()/store(), 2) ResourceBundle for internationalization, 3) XML format with loadFromXML()/storeToXML(). Best practices: use proper encoding (UTF-8), handle missing properties, consider hierarchical properties, escape special characters. Properties files useful for configuration, externalized strings, application settings.
Character encodings convert between bytes and characters. Handling: 1) Specify explicit encoding in Reader/Writer, 2) Use StandardCharsets constants, 3) Handle encoding errors (replacement, reporting), 4) Consider BOM (Byte Order Mark). Common issues: platform default encoding, corrupted data, encoding mismatch. Always specify encoding explicitly.
AsynchChannel enables non-blocking I/O operations. Benefits: 1) Improved scalability, 2) Better resource utilization, 3) Reduced thread overhead. Completion handling through: CompletionHandler, Future, or callback. Suitable for: network I/O, many concurrent operations. Requires careful error handling and completion state management.
Custom serialization through private readObject()/writeObject() methods. Uses: 1) Control serialization format, 2) Handle sensitive data, 3) Maintain invariants, 4) Version compatibility. Implementation must handle: all fields, superclass state, validation, security. Consider readResolve()/writeReplace() for object replacement.
Buffering reduces system calls by reading/writing larger chunks. BufferedReader/BufferedWriter add buffering to character streams, improving performance. Use when: 1) Reading/writing text files line by line, 2) Frequent small reads/writes, 3) Network I/O. Buffer size affects performance - default usually sufficient. Remember to close (preferably with try-with-resources).
FileChannel provides direct file access with features: 1) Memory-mapped files, 2) Direct buffer access, 3) File locking, 4) Scatter/gather operations. NIO Buffers offer: 1) Direct memory access, 2) Bulk data operations, 3) Buffer pooling. Performance benefits from: reduced copying, system calls, and better memory usage. Suitable for high-performance I/O.
File locking through FileChannel: shared (read) or exclusive (write) locks. Considerations: 1) Lock granularity, 2) Cross-process coordination, 3) Deadlock prevention, 4) Platform differences. FileLock must be released explicitly. Useful for concurrent access control. Remember: some platforms don't enforce mandatory locking.
